【Python笔记】基础篇（六）-优快云博客

本文链接：https://blog.youkuaiyun.com/HK_light/article/details/131173490

本文详细介绍了Python中的数据容器，包括列表、元组、字符串、序列、集合和字典的定义、语法、操作方法以及各自的特点。特别强调了它们之间的区别，如列表的可修改性、元组的不可修改性、字符串的不可变性、集合的无序性和字典的键值对特性。此外，还提供了相关操作的实例，如遍历、添加、删除、查找和统计元素等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考视频和资料：第一阶段-第六章-01-数据容器入门_哔哩哔哩_bilibili

Day06

对应视频：第一阶段第六章

第六章数据容器

一、基本知识点

学习数据容器，就是为了批量存储或批量使用多份数据

1.定义

（1）数据容器：一种可以容纳多份数据的数据类型
（2）元素：容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

2.分类

                 （1）依据
                        是否支持重复元素
                        是否可以修改
                        是否有序
                        ......

（2）类型
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二、数据容器：list（列表）

1.列表的基本知识

                （1）元素：列表中的每一个数据称之为元素
（2）标识：[]
                        列表内每一个元素之间用逗号隔开
                （3）数据类型：list

2.列表的语法

                （1）字面量
                        [元素1,元素2,元素3,...]
                （2）定义变量
                        变量名称 = [元素1,元素2,元素3,...]

list1 = ["python","study","up"]
print(list1)   # 结果：['python', 'study', 'up']
print(type(list1))   # 结果：<class 'list'>

（3）定义空列表
a.变量名称 = []
b.变量名称 = list()
（4）元素的数据类型不受限制

list2 = ["python",666,True]
print(list2)   # 结果：['python', 666, True]
print(type(list2))   # 结果：<class 'list'>

（5）支持列表嵌套

list3 = [[1,2,3],[4,5,6]]
print(list3)   # 结果：[[1, 2, 3], [4, 5, 6]]
print(type(list3))   # 结果：<class 'list'>

3.列表的下标索引

（1）定义

使用下标索引可以取出特定位置的数据

                 （2）语法
                        列表[下标]
                        列表中的每一个元素都具有对应位置的下标索引，从前往后，从0开始依次递增

# 正向下标索引取出元素
list1 = ["Tom","rose","lily"]
print(list1[0])   # 结果：Tom
print(list1[1])   # 结果：rose
print(list1[2])   # 结果：lily
# 下面一行语句会报错:IndexError: list index out of range
# 使用下标索引取数据，下标不能超出列表的范围
# print(list1[3])

（3）反向下标索引
从后往前，从-1开始依次递减（-1，-2，-3，...）

（因为0没有正负，所以如果用0开始就无法与正向区别开）

# 反向下标索引取出元素
list1 = ["Tom","rose","lily"]
print(list1[-1])   # 结果：lily
print(list1[-2])   # 结果：rose
print(list1[-3])   # 结果：Tom

（4）嵌套的下标索引

例如：第二个列表中的第一个元素列表[1][0]

# 取出嵌套列表中的元素
list2 = [[1,2,3],[4,5,6]]
print(list2[1][0])   # 结果：4

【注意】：通过下标索引取数据，不可以超过列表的范围

4.列表的常用操作（方法）

Python中，若将函数定义为class（类）的成员，那么函数就会被称为：方法

方法的调用需要先获得方法所在class类的对象，再通过类对象获取方法——面向对象

                （1）查询元素
                        查询指定元素在列表的下标
                        语法：
                                列表.index(元素)
                        index就是列表对象（变量）内置的方法（函数）
                        若找不到，报错ValueError
【注意】：该语句查询不了嵌套列表，且查询到的是正向索引

test_list = ["python","study","up"]

# 1.查询某个元素在列表中的索引下标
index = test_list.index("study")
print(f"study在列表中的索引下标是：{index}")   # 结果：study在列表中的索引下标是：1
# 若被查询的元素不存在，会报错:ValueError: 'sleep' is not in list
# index = test_list.index("sleep")
# print(f"sleep在列表中的索引下标是：{index}")

                （2）修改元素
                        修改特定位置（索引）的元素值
                        语法：
                                列表[下标] = 值

test_list = ["python","study","up"]
# 2.修改特定下标索引的值
test_list[2] = "go"
print(f"列表被修改后的值为：{test_list}")   # 结果：列表被修改后的值为：['python', 'study', 'go']

                （3）插入元素
                        在指定下标位置，插入指定的元素
                        语法：
                                列表.insert(下标，元素)

test_list = ["python","study","up"]
# 3.在指定下标位置插入指定的元素
test_list.insert(1,"it")
print(f"在列表位置1出插入元素后的值为：{test_list}")   # 结果：在列表位置1出插入元素后的值为：['python', 'it', 'study', 'up']

                （4）追加元素
                        语法：
                                a.追加单个元素

列表.append(元素)
将指定元素，追加到列表的尾部

test_list = ["python","study","up"]
# 4_1.追加单个元素：将指定元素，追加到列表的尾部
test_list.append("come on")
print(f"追加单个元素后，列表的值为：{test_list}")   # 结果：追加单个元素后，列表的值为：['python', 'study', 'up', 'come on']

b.追加多个元素

列表.extend(其他数据容器)
将其他数据容器的内容取出，依次追加到列表尾部

test_list = ["python","study","up"]
# 4_2.追加多个元素：将其他数据容器的内容取出，依次追加到列表尾部
list1 = [1,2,3]
test_list.extend(list1)
print(f"追加多个元素后，列表的值为：{test_list}")   # 结果：追加多个元素后，列表的值为：['python', 'study', 'up', 1, 2, 3]

                （5）删除功能
                        语法：
                                a.del 列表[下标]
                                        删除指定下标的元素

# 5_1.删除指定下标元素：del
test_list = ["python","study","up"]
del test_list[2]
print(f"通过del删除下标为2的元素后，列表的值为：{test_list}")   # 结果：通过del删除下标为2的元素后，列表的值为：['python', 'study']

                                b.列表.pop(下标)
                                        将指定下标元素取出来，再返回出去
                                        当不指定下标时，即列表.pop()，默认删除最后一位

# 5_2.删除指定下标元素：pop
test_list = ["python","study","up"]
element = test_list.pop(2)
print(f"通过pop删除下标为2的元素后，列表的值为：{test_list}。删除的元素为：{element}")   # 结果：通过pop删除下标为2的元素后，列表的值为：['python', 'study']。删除的元素为：up

c.列表.remove(元素)
删除指定元素在列表中的第一个匹配项（从前往后）

# 5_3.删除指定元素在列表中的第一个匹配项
test_list = ["python","study","up","python"]
test_list.remove("python")
print(f"通过remove删除python元素后，列表的值为：{test_list}")   # 结果：通过remove删除python元素后，列表的值为：['study', 'up', 'python']

d.列表.clear()
清空列表内容

# 5_4.清空列表
test_list = ["python","study","up","python"]
test_list.clear()
print(f"清空列表后，列表的值是：{test_list}")   # 结果：清空列表后，列表的值是：[]

                        del与pop的区别：
                                a.del是删除命令，pop与remove为list的内置方法
                                b.列表就是一个python内置类，pop是列表类封装的实现元素删除功能的方法

补充：函数和方法本质相同，只不过方法是封装在一个类中，用于被该类创建的对象调用
可以说，方法是函数的一种

                （6）统计功能
                        语法：
                                a.列表.count(元素)
                                        统计某元素在列表中的数量，给一个返回值

# 6.统计某元素在列表中的数量
test_list = ["python","study","up","python"]
count = test_list.count("python")
print(f"列表中python元素出现的次数是：{count}")   # 结果：列表中python元素出现的次数是：2

b.len(列表)
统计列表内，有多少元素，给一个返回值

# 7.统计列表有多少个元素
test_list = ["python","study","up","python"]
count = len(test_list)
print(f"列表中的元素个数是:{count}")   # 结果：列表中的元素个数是:4

建议：不用硬记所有的功能方法，只需要有一个印象，知道有这样一个方法就行。需要的时候再查阅资料

5.列表的特点

                （1）可以容纳多个元素（上限为2**63-1、9223372036854775807个）
                （2）可以容纳不同类型的元素（混装）
                （3）数据是有序存储的（有下标序号）
                （4）允许重复数据存在
                （5）可以修改（增加或删除元素等）

6.常用功能练习

test_list = [21,25,21,23,22,20]

# 追加数字31，到列表尾部
test_list.append(31)
print(f"在尾部追加数字31后，列表的值为：{test_list}")   # 结果：在尾部追加数字31后，列表的值为：[21, 25, 21, 23, 22, 20, 31]

# 追加一个新列表[29,33,30]，到列表尾部
test_list.extend([29,33,30])
print(f"在尾部追加新列表[29,33,30]后，列表的值为：{test_list}")   # 结果：在尾部追加新列表[29,33,30]后，列表的值为：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

# 取出第一个元素
num = test_list.pop(0)
print(f"取出第一个元素后，列表的值为：{test_list}。所取出的元素值为：{num}")   # 结果：取出第一个元素后，列表的值为：[25, 21, 23, 22, 20, 31, 29, 33, 30]。所取出的元素值为：21

# 取出最后一个元素
length = len(test_list)
# num = test_list.pop(-1)
num = test_list.pop(length-1)
print(f"取出最后一个元素后，列表的值为：{test_list}。所取出的元素值为：{num}")   # 结果：取出最后一个元素后，列表的值为：[25, 21, 23, 22, 20, 31, 29, 33]。所取出的元素值为：30

# 查找元素31,在列表中的下标位置
position = test_list.index(31)
print(f"元素31在列表中的下标位置为：{position}")   # 结果：元素31在列表中的下标位置为：5

7.list（列表）的遍历

                 将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代
                （1）方法：借助循环语句
                        a.while循环
                                index = 0
                                while index < len(列表)
                                        元素 = 列表[index]
                                        对元素进行处理
                                        index += 1

test_list = ["python","study","up"]
def list_while_func(use_list):
    """
    使用while循环遍历列表元素
    1.循环变量通过索引下标来控制，默认为0
    2.每次循环都将索引下标变量+1
    3.循环条件：遍历的索引下标 < 列表长度
    :param use_list:从外部传进来的需要操作的列表
    :return: None
    """
    # index:列表元素下标
    index = 0
    while index < len(use_list):
        # element：临时存储当前遍历到的元素值
        element = use_list[index]
        print(f"列表的元素：{element}")
        # 每次循环都将索引下标变量+1
        index += 1

list_while_func(test_list)
# 结果：
# 列表的元素：python
# 列表的元素：study
# 列表的元素：up

                        b.for循环（更便利）
                                for 临时变量 in 数据容器
                                        对临时变量进行处理

test_list = ["python","study","up"]
def list_for_func(use_list):
    """
    使用for循环遍历列表
    依次取出列表中的元素赋给临时变量，然后进行输出
    :param use_list: 从外部传进来的需要操作的列表
    :return: None
    """
    for element in use_list:
        print(f"列表的元素：{element}")

list_for_func(test_list)
# 结果：
# 列表的元素：python
# 列表的元素：study
# 列表的元素：up

                （2）while循环和for循环的区别
                        a.在循环控制上：
                                while循环可以自定循环条件，并自行控制
                                for循环不可以自定循环条件，只可以一个个从容器内取出数据
                        b.在无限循环上：
                                while循环可以通过条件控制做到无限循环
                                for循环理论上不可以，因为被遍历的容器容量不是无限的
                        c.在使用场景上：
                                while循环适用于任何想要循环的场景
                                for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
                        for循环更简单，while循环更灵活

（3）取出列表内的偶数小练习

test_list = [1,2,3,4,5,6,7,8,9,10]

def list_while(use_list):
    index = 0
    new_list = []
    while index < len(use_list):
        if use_list[index] % 2 == 0:
            element = use_list.pop(index)
            new_list.append(element)
        index += 1

    return new_list

def list_for(use_list):
    i = 0
    new_list = []
    for x in use_list:
        if x % 2 == 0:
            element = use_list.pop(i)
            new_list.append(element)
        i += 1
    return new_list

print(f"通过while循环，从列表：[1,2,3,4,5,6,7,8,9,10]中取出偶数，组成新列表：{list_while(test_list)},取出后原来的列表为：{test_list}")
# 结果：通过while循环，从列表：[1,2,3,4,5,6,7,8,9,10]中取出偶数，组成新列表：[2, 4, 6, 8, 10],取出后原来的列表为：[1, 3, 5, 7, 9]
print(f"通过for循环，从列表：{test_list}中取出偶数，组成新列表：{list_for(test_list)},取出后原来的列表为：{test_list}")
# 结果：通过for循环，从列表：[1, 3, 5, 7, 9]中取出偶数，组成新列表：[],取出后原来的列表为：[1, 3, 5, 7, 9]
# 原因见补充
test_list = [1,2,3,4,5,6,7,8,9,10]
print(f"通过for循环，从列表：[1,2,3,4,5,6,7,8,9,10]中取出偶数，组成新列表：{list_for(test_list)},取出后原来的列表为：{test_list}")
# 结果：通过for循环，从列表：[1,2,3,4,5,6,7,8,9,10]中取出偶数，组成新列表：[2, 4, 6, 8, 10],取出后原来的列表为：[1, 3, 5, 7, 9]

补充：

        在python中，根据实参的对象类型，分为可变对象和不可变对象
        当实参是可变对象（如列表和字典等），函数参数的传递方式将采用引用传递方式——相当于直接使用它本身，改变它的值会影响它本身。
        当实参是不可变对象（如字符串，整型和浮点型等），函数传递时会复制一份再进行传递，这时在函数内改变它的值不会影响原来的值

三、数据容器：tuple（元组）

1.元组基本知识

元组同列表一样，可以封装多个、不同类型的元素
特点：元组一旦定义完成，就不可以被修改——相当于一个只允许读的list

2.语法

                 数据可以是不同的数据类型
                （1）定义元组字面量
                        (元素,元素,元素,...,元素)
                （2）定义元组变量
                        变量名称 = (元素,元素,元素,...,元素)

t1 = ("python",666,True)
print(f"t1的数据类型是：{type(t1)},内容是：{t1}")
# 结果：t1的数据类型是：<class 'tuple'>,内容是：('python', 666, True)

                （3）定义空元组
                        a.变量名称 = ()
                        b.变量名称 = tuple()

t2 = ()
t3 = tuple()
print(f"t2的数据类型是：{type(t2)},内容是：{t2}")
# 结果：t2的数据类型是：<class 'tuple'>,内容是：()
print(f"t3的数据类型是：{type(t3)},内容是：{t3}")
# 结果：t3的数据类型是：<class 'tuple'>,内容是：()

【注意】：当元组只有一个数据的时候，这个数据后面要添加逗号，不然就不是元组类型

t4 = ("hello")
print(f"t4的数据类型是：{type(t4)},内容是：{t4}")
# 结果：t4的数据类型是：<class 'str'>,内容是：hello
t4 = ("hello",)
print(f"t4的数据类型是：{type(t4)},内容是：{t4}")
# 结果：t4的数据类型是：<class 'tuple'>,内容是：('hello',)

（4）元组也支持嵌套

t5 = ((1,2,3),(4,5,6))
print(f"t5的数据类型是：{type(t5)},内容是：{t5}")
# 结果：t5的数据类型是：<class 'tuple'>,内容是：((1, 2, 3), (4, 5, 6))

（5）元组也支持下标索引

num = t5[1][0]
print(f"取出值的数据类型是：{type(num)},内容是：{num}")
# 结果：取出值的数据类型是：<class 'int'>,内容是：4

3.元组的相关操作

【注意】：元组不可修改，也就没有列表中插入删除等操作
（1）查找
index()

# 查询元组中某个数据的下标
t1 = ("python",666,True)
index = t1.index(666)
print(f"666在元组中的下标为：{index}")   
# 结果：666在元组中的下标为：1

（2）统计某个数据在元组中出现的次数
count()

# 统计元组中某个数据出现的次数
t2 = ("python",666,True,"python",666,True,"python",666,True)
count = t2.count(666)
print(f"666在元组中出现的次数为：{count}")
# 结果：666在元组中出现的次数为：3

（3）统计元组内的元素个数
len(元组)

# 统计元组的长度
t2 = ("python",666,True,"python",666,True,"python",666,True)
length = len(t2)
print(f"元组t2的长度为：{length}")
# 结果：元组t2的长度为：9

（4）元组的遍历：for循环和while循环

# 元组的遍历
t1 = ("python",666,True)
# while循环遍历
index = 0
while index < len(t1):
    element = t1[index]
    print(f"元组的元素有：{element}")
    index += 1
# 结果：
# 元组的元素有：python
# 元组的元素有：666
# 元组的元素有：True

# for循环遍历
for element in t1:
    print(f"元组的元素有：{element}")
# 结果：
# 元组的元素有：python
# 元组的元素有：666
# 元组的元素有：True

# 元组的内容不可以被修改
# t1 = ("python",666,True)
# t1[0] = 1


# # 元组中list的内容可被修改
# t1 = (1,2,3,[3,5,6])
# print(f"修改前：{t1}")
# t1[3][0] = 4
# print(f"修改后：{t1}")

4.元组的注意事项

（1）元组的内容不可以被修改
（2）元组内list的内容是可以被修改的（修改元素、增加、删除和反转等）

5.元组的特点

                （1）可以容纳多个数据
                （2）可以容纳不同类型的数据
                （3）数据是有序存储的（下标索引）
                （4）允许重复数据纯在
                （5）不可以修改（增加或删除元素等）
                （6）支持for循环
                大部分与列表一致，不同于元组不可修改

6.元组基本操作练习

"""
元组基本操作练习
"""
t1 = ("张三",18,["football","music"])
# 查询年龄所在下标
print(f"年龄所在下标为：{t1.index(18)}")
# 结果：年龄所在下标为：1

# 查询姓名
print(f"姓名为：{t1[0]}")   # 结果：姓名为：张三

# 删除学生爱好中的football
del t1[2][0]
print(f"删除football后，元组内容为：{t1}")
# 结果：删除football后，元组内容为：('张三', 18, ['music'])

# 增加爱好coding
print(f"删除football后,music所在位置的数据类型为：{type(t1[2])}")
# 结果：删除football后,music所在位置的数据类型为：<class 'list'>

# list(t1[2])
t1[2].insert(1,"coding")
print(f"插入coding后，元组的内容为：{t1}")
# 结果：插入coding后，元组的内容为：('张三', 18, ['music', 'coding'])

四、数据容器：str（字符串）

1.基本知识点

a.字符串可以存放任意数量的字符，可以看做是字符的容器

                b.同样字符串也支持下标访问
                        前往后，从下标0开始
                        后往前，从下标-1开始

test_str = "Hello python gogogo"
print(f"字符串下标为1的值为：{test_str[1]},下标为-18的值为：{test_str[-18]}")
# 结果：字符串下标为1的值为：e,下标为-18的值为：e

c.字符串同元组一样，是一个无法修改的数据容器
如果必须要修改，只能得到一个新的字符串，旧的字符串无法修改

test_str[1] = "o"   # 报错：TypeError: 'str' object does not support item assignment

2.字符串的常用操作

                （1）查找特定字符串的下标索引值
                        字符串.index(字符串)
                                返回的是起始下标

test_str = "Hello python and gogogo"
# index方法
value = test_str.index("and")
print(f"and在字符串{test_str}中的起始下标为：{value}")
# 结果：and在字符串Hello python and gogogo中的起始下标为：13

                （2）字符串的替换
                        字符串.replace(字符串1,字符串2)
                                将字符串内的字符串1替换为字符串2

# replace方法
test_str = "Hello python and gogogo"
new_str = test_str.replace("and","then")
print(f"将字符串{test_str}中的and替换为then后得到：{new_str}")
# 结果：将字符串Hello python and gogogo中的and替换为then后得到：Hello python then gogogo

                        【注意】：替换后得到的是一个新的字符串，并不是在原来的基础上进性修改

                （3）字符串的分割
                        字符串.split(分隔符字符串)
                                按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

# split方法
test_str = "Hello python and gogogo"
new_list = test_str.split(" ")
print(f"将字符串{test_str}对空格按照split进行分割后，得到：{new_list},其类型是：{type(new_list)}")
# 结果：将字符串Hello python and gogogo对空格按照split进行分割后，得到：['Hello', 'python', 'and', 'gogogo'],其类型是：<class 'list'>

                        【注意】：字符串本身并没有被改变，而是得到了一个列表对象

（4）字符串的规整
                        a.字符串.strip()
                                去掉前后空格

# 字符串的规整
test_str = "  Hello python and gogogo  "
new_str = test_str.strip()
print(f"对字符串{test_str}进行strip()操作后，字符串内容为：{new_str}")
# 结果：对字符串  Hello python and gogogo  进行strip()操作后，字符串内容为：Hello python and gogogo

b.字符串.strip(字符串)
去掉前后指定字符串

test_str = "12Hello python and gogogo21"
new_str = test_str.strip("12")
print(f"对字符串{test_str}进行strip()操作后，字符串内容为：{new_str}")
# 结果：对字符串12Hello python and gogogo21进行strip()操作后，字符串内容为：Hello python and gogogo

                                【注意】：是按照单个字符移除
               传入的是12，其实就是按照1和2单个字符移除。并且按照的是单个字符进行匹配移除，而不是完全按照符合12这种顺序进行删除

（5）字符串的次数统计

字符串.count(字符串)

test_str = "Hello python and gogogo"
count = test_str.count("go")
print(f"字符串{test_str}中go出现的次数为：{count}")
# 结果：字符串Hello python and gogogo中go出现的次数为：3

（6）字符串的长度

len(字符串)

test_str = "Hello python and gogogo"
print(f"字符串{test_str}的长度为：{len(test_str)}")
# 结果：字符串Hello python and gogogo的长度为：23

（7）字符串的遍历
for循环和while循环

# 字符串的遍历
# for循环遍历
test_str = "pyt"
for element in test_str:
    print(element)
# 结果：
# p
# y
# t

# while循环遍历
index = 0
while index < len(test_str):
    print(test_str[index])
    index += 1
# 结果：
# p
# y
# t

3.字符串的特点

                （1）只可以存储字符串
                （2）长度任意（取决于内存大小）
                （3）支持下标索引
                （4）允许重复字符串存在
                （5）不可以修改（增加或删除元素等）
                （6）支持for循环

4.分割字符串小练习

test_str = "itheima itcast boxuegu"

# 统计it字符个数
num = test_str.count("it")
print(f"字符串{test_str}中字符的个数为：{num}")
# 结果：字符串itheima itcast boxuegu中字符的个数为：2

# 将空格替换为|
new_str = test_str.replace(" ","|")
print(f"字符串{test_str}中空格替换为|后为：{new_str}")
# 结果：字符串itheima itcast boxuegu中空格替换为|后为：itheima|itcast|boxuegu

# 按照|进行字符串的分割
new_str1 = new_str.split("|")
print(f"字符串{new_str}按照|进行分割后为：{new_str1}")
# 结果：字符串itheima|itcast|boxuegu按照|进行分割后为：['itheima', 'itcast', 'boxuegu']

五、数据容器：序列

1.定义

序列：内容连续、有序，可以使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列

2.切片

                （1）定义
                        从一个序列中，取出一个子序列
                （2）语法
                        序列[起始下标:结束下标:步长]
                        表示从序列中，从指定位置开始，依次取出元素到指定位置结束，得到一个新序列：
                        起始下标可以省略，省略视作从头开始
                        结束下标（不含）可以省略，省略视作到尾结束
                        步长表示，依次取元素的间隔——默认步长为1
                                步长N表示，每次跳过N-1个元素取
                                步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
                                步长可以省略，省略表示步长为1：[起始下标:结束下标]
                【注意】：切片操作不会影响序列本身，而是会得到一个新的序列

# 对列表list进行切片
my_list = [0,1,2,3,4,5,6]
# 下标1开始，下标4（不含）结束，步长1
new_list = my_list[1:4]
print(new_list)  # 结果：[1, 2, 3]

# 对元组tuple进行切片
my_tuple = (0,1,2,3,4,5,6)
# 从头开始，到最后结束，步长1
new_tuple = my_tuple[:]
print(new_tuple)  # 结果：(0, 1, 2, 3, 4, 5, 6)

# 对字符串str进行切片
my_str = "01234567"
# 从头开始，到下标4（不含）结束，步长2
new_str = my_str[::2]
print(new_str)  # 结果：0246

# 对字符串str进行反向切片
my_str = "01234567"
# 从最后开始，到头结束，步长-1
new_str = my_str[::-1]
# 相当于反向取
print(new_str)  # 结果：76543210

# 对列表list进行反向切片
my_list = [0,1,2,3,4,5,6]
# 下标3开始，下标1（不含）结束，步长-1
new_list = my_list[3:1:-1]
print(new_list)  # 结果：[3, 2]

# 对元组tuple进行反向切片
my_tuple = (0,1,2,3,4,5,6)
# 从最后开始，到头结束，步长-2
new_tuple = my_tuple[::-2]
print(new_tuple)  # 结果：(6, 4, 2, 0)

3.切片小练习

"""
切片小练习
要求输出：努力学python
"""
str1 = "上向天天，nohtyp学力努快，习学好好"

# 方法一：切片倒序取出
new_str = str1[13:4:-1]
print(new_str)  # 结果：努力学python

# 另一种写法
new_str = str1[::-1][6:15]
print(new_str)  # 结果：努力学python

# 方法二：split分割，replace替换快为空，逆置
new_str1 = str1.split("，")
new_str2 = new_str1[1]
new_str3 = new_str2.replace("快","")
new_str4 = new_str3[::-1]
print(new_str4)  # 结果：努力学python

# 另一种写法
new_str = str1.split("，")[1].replace("快","")[::-1]
print(new_str)  # 结果：努力学python

六、数据容器：set（集合）

1.列表，元组和字符串的综合分析

（1）列表：可修改，支持重复元素且有序
（2）元组、字符串不可以修改，支持重复元素且有序

2.集合的特点

                （1）不支持元素重复，相当于自带去重功能
                （2）内容无序
               （3）不支持下标索引访问（因为集合是无序的）
               （4）允许修改
               （5）可以容纳多个不同类型的数据
               （6）支持for循环

3.集合的语法

                （1）定义字面量
                        {元素,元素,......,元素}
                （2）定义集合变量
                        变量名称 = {元素,元素,......,元素}

set1 = {"好好学习","python","天天向上","好好学习","python","天天向上","好好学习","python","天天向上"}
print(f"str1的内容是：{set1},数据类型是：{type(set1)}")
# 结果：str1的内容是：{'python', '好好学习', '天天向上'},数据类型是：<class 'set'>

（3）定义空集合
变量名称 = set()

set2 = set()
print(f"str2的内容是：{set2},数据类型是：{type(set2)}")
# 结果：str2的内容是：set(),数据类型是：<class 'set'>

4.集合的常用操作

                （1）添加新元素
                        集合.add(元素)
                                将指定元素添加到集合内
                                集合本身被修改
                                若添加了集合本身就有的元素，相当于没有添加

set1 = {"好好学习","python","天天向上"}
# 添加元素
set1.add("come on")
print(f"添加come on元素后，集合的内容是：{set1}")
# 结果：添加come on元素后，集合的内容是：{'天天向上', 'come on', '好好学习', 'python'}

                （2）移除元素
                        集合.remove(元素)
                                将指定元素从集合内移除
                                集合本身被修改

set1 = {"好好学习","python","天天向上"}
# 移除元素
set1.remove("python")
print(f"移除python元素后，集合的内容是：{set1}")
# 结果：移除python元素后，集合的内容是：{'天天向上', '好好学习'}

                （3）随机取出元素
                        集合.pop()
                                随机从集合中取出一个元素
                                返回一个元素，并且集合本身被修改

set1 = {"好好学习","python","天天向上"}
# 随机取出元素
set2 = set1.copy()
element = set2.pop()
print(f"集合{set1}随机移除元素后，集合的内容是：{set2}，移除的元素是：{element}")
# 结果：集合{'天天向上', '好好学习', 'python'}随机移除元素后，集合的内容是：{'好好学习', 'python'}，移除的元素是：天天向上

                （4）清空集合
                        集合.clear()
                               集合本身被修改

set1 = {"好好学习","python","天天向上"}
# 清空集合
set1.clear()
print(f"集合清空后，集合的内容是：{set1}")
# 结果：集合清空后，集合的内容是：set()

                （5）取出两个集合的差集
                        集合1.difference(集合2)
                               取出集合1和集合2的差集（集合1有而集合2没有的）
                               得到一个新的集合，原来的集合不受影响

# 取出两个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出的集合为：{set3}")  # 结果：取出的集合为：{2, 3}
print(f"取出差集后，原来的set1为：{set1},set2为：{set2}")
# 结果：取出差集后，原来的set1为：{1, 2, 3},set2为：{1, 5, 6}

                （6）消除两个集合的交集
                        集合1.difference_update(集合2)
                               在集合1内删除与集合2相同的元素
                               集合1被修改，集合2不变

# 消除两个集合的交集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除交集后，原来的set1为:{set1},set2为：{set2}")
# 结果：消除交集后，原来的set1为:{2, 3},set2为：{1, 5, 6}

                （7）两个集合合并
                        集合1.union(集合2)
                               将集合1和2合并，组成一个新的集合
                               得到一个新的集合，原来的集合不变

# 合并两个集合
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"两个集合合并后为：{set3}")  # 结果：两个集合合并后为：{1, 2, 3, 5, 6}
print(f"原来的set2为：{set2},set1为：{set1}")
# 结果：原来的set2为：{1, 5, 6},set1为：{1, 2, 3}

（8）统计集合中元素的数量

len(集合)

计数的结果是去重之后的结果，因为集合元素不能重复

# 统计集合中元素的数量
# 因为集合内的元素不能重复，所以计数的结果是去完重之后的结果
set1 = {1,2,3,1,2,3,1,2,3}
print(f"集合内元素的数量为：{len(set1)}")
# 结果：集合内元素的数量为：3

                （9）集合的遍历
                        因为集合无序，所以不支持下标索引，也就不能使用下标索引的while循环
                        但是集合支持for循环遍历

# 集合的遍历
set1 = {1,2,3}
for x in set1:
    print(x)
# 结果：
# 1
# 2
# 3

5.信息去重小练习

my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']

# 定义一个空集合
set1 = set()
# 通过for循环遍历列表
for element in my_list:
    # 在for循环中将列表的元素添加至集合
    set1.add(element)
# 最终得到元素去重后的集合对象，并打印输出
print(f"原来列表中的内容是：{my_list}")
# 结果：原来列表中的内容是：['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']
print(f"循环赋值去重后，得到的集合内容是：{set1}")
# 结果：循环赋值去重后，得到的集合内容是：{'itheima', '传智播客', '黑马程序员', 'best', 'itcast'}

七、数据容器：dict（字典、映射）

1.定义

字典的作用：通过【key】找到对应的【value】

2.语法

                （1）定义字典字面量
                        {key:value,key:value,......,key:value}
                （2）定义字典变量
                        my_dict = {key:value,key:value,......,key:value}

# 定义字典
dict1 = {"张三":95,"李四":92,"玄武":98,"白虎":100}
print(f"dict1中的内容是：{dict1},其数据类型是：{type(dict1)}")
# 结果：dict1中的内容是：{'张三': 95, '李四': 92, '玄武': 98, '白虎': 100},其数据类型是：<class 'dict'>

               （3）定义空字典
                        my_dict = {}
                        my_dict = dict()

# 定义空字典
dict2 = {}
dict3 = dict()
print(f"dict2中的内容是：{dict2},其数据类型是：{type(dict2)}")
# 结果：dict2中的内容是：{},其数据类型是：<class 'dict'>
print(f"dict3中的内容是：{dict3},其数据类型是：{type(dict3)}")
# 结果：dict3中的内容是：{},其数据类型是：<class 'dict'>

（4）字典内的key不允许重复
若定义了重复的key，对于相同的key，后面数据的会将前面的值覆盖掉

# 定义重复key的字典
# 对于重复的key，后面的内容会将前面的覆盖掉
dict4 = {"张三":95,"张三":92,"玄武":98,"白虎":100}
print(f"定义key重复字典的内容是：{dict4}")
# 结果：定义key重复字典的内容是：{'张三': 92, '玄武': 98, '白虎': 100}

（5）不可以使用下标索引
（6）可以通过key值来取得对应的value
字典[key值]

# 从字典中基于key获取value
dict1 = {"张三":95,"李四":92,"玄武":98,"白虎":100}
score1 = dict1["张三"]
print(f"张三的分数是：{score1}")
# 结果：张三的分数是：95
score2 = dict1["白虎"]
print(f"白虎的分数是：{score2}")
# 结果：白虎的分数是：100

（7）字典支持嵌套
字典的key和value可以是任意数据类型，但是key不可为字典

# 定义嵌套字典
dict1 = {
    "张三":{
        "语文":105,
        "数学":110,
        "英语":90
    },"李四":{
        "语文":100,
        "数学":120,
        "英语":93
    }
}
print(dict1)
# 结果：{'张三': {'语文': 105, '数学': 110, '英语': 90}, '李四': {'语文': 100, '数学': 120, '英语': 93}}

# 从嵌套字典中获取数据
# 查看李四的数学信息
score = dict1["李四"]["数学"]
print(f"李四的数学成绩是：{score}")
# 结果：李四的数学成绩是：120

小技巧：对于像字典和列表这样的元素定义，可以在里面使用回车，使得看上去更直观。（字典和列表等的元素分割靠的是逗号）

3.字典的常用操作

                 （1）新增元素（新增的key在原来的字典中不存在）
                        字典[key] = value
                                字典被修改，增加新的元素

dict1 = {"张三":95,"李四":92,"玄武":98}
# 新增元素
dict1["白虎"] = 60
print(dict1)  # 结果：{'张三': 95, '李四': 92, '玄武': 98, '白虎': 60}

                （2）更新元素（新增的key在原来的字典中存在）
                        字典[key] = Value
                                字典被修改，元素被更新

dict1 = {"张三":95,"李四":92,"玄武":98}
# 更新元素
dict1["玄武"] = 100
print(dict1)  # 结果：{'张三': 95, '李四': 92, '玄武': 100}

               （3）删除元素
                        字典.pop(key)
                                获取指定key的value，同时删除字典里面对应的key的数据

dict1 = {"张三":95,"李四":92,"玄武":98}
# 删除元素
score = dict1.pop("李四")
print(f"删除李四的数据后，字典值为：{dict1}，删除的内容为:{score}")
# 结果：删除李四的数据后，字典值为：{'张三': 95, '玄武': 98}，删除的内容为:92

                （4）清空字典
                        字典.clear()
                                字典被修改，元素被清空

dict1 = {"张三":95,"李四":92,"玄武":98}
# 清空元素
dict1.clear()
print(dict1)  # 结果：{}

                （5）获取全部的key
                        字典.keys()
                                可以用于字典的遍历（for循环）

# 获取全部的key
dict1 = {"张三":95,"李四":92,"玄武":98}
keys = dict1.keys()
print(keys)  # 结果：dict_keys(['张三', '李四', '玄武'])

               （6）字典的遍历
                        for循环
                        因为字典不支持下标索引，也就不能使用下标索引的while循环

dict1 = {"张三":95,"李四":92,"玄武":98}
# 遍历字典
# 方法一：通过获取全部的key来进行遍历
for key in keys:
    print(f"{key}的成绩是：{dict1[key]}")
# 结果：
# 张三的成绩是：95
# 李四的成绩是：92
# 玄武的成绩是：98

# 方法二：直接对字典进行for遍历
for key in dict1:
    print(f"{key}的成绩是：{dict1[key]}")
# 结果：
# 张三的成绩是：95
# 李四的成绩是：92
# 玄武的成绩是：98

（7）统计字典的元素个数

# 统计字典中的元素个数
dict1 = {"张三":95,"李四":92,"玄武":98}
len = len(dict1)
print(len)  # 结果：3

4.字典的特点

                （1）可以容纳多个不同类型的数据
                （2）每一份数据的key值与value值都是对应的
                （3）可以通过Key获取到Value，Key不可重复（重复会覆盖）
                （4）不支持下标索引
                （5）可以修改（增加或删除更新元素等）
                （6）支持for循环，不支持下标索引的while循环

5.升职加薪小练习

dict1 = {
    "张三":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },"李四":{
        "部门":"市场部",
        "工资":5000,
        "级别":2
    },"玄武":{
        "部门":"市场部",
        "工资":7000,
        "级别":3
    },"青龙":{
        "部门":"科技部",
        "工资":4000,
        "级别":1
    },"白虎":{
        "部门":"市场部",
        "工资":6000,
        "级别":1
    }
}
print(f"升职加薪前，员工的信息如下：{dict1}")
# 结果：升职加薪前，员工的信息如下：{'张三': {'部门': '科技部', '工资': 3000, '级别': 1}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '玄武': {'部门': '市场部', '工资': 7000, '级别': 3}, '青龙': {'部门': '科技部', '工资': 4000, '级别': 1}, '白虎': {'部门': '市场部', '工资': 6000, '级别': 1}}

# for key in dict1:
#     if dict1[key]["级别"] == 1:
#         dict1[key]["级别"] += 1
#         dict1[key]["工资"] += 1000

# 这样写更好，修改过程中不会直接更改原来字典的内容，以后的操作变更更方便
for key in dict1:
    if dict1[key]["级别"] == 1:
        element_dict = dict1[key]
        element_dict["级别"] += 1
        element_dict["工资"] += 1000
        dict1[key] = element_dict

print(f"升职加薪后，员工的信息如下：{dict1}")
# 结果：升职加薪后，员工的信息如下：{'张三': {'部门': '科技部', '工资': 4000, '级别': 2}, '李四': {'部门': '市场部', '工资': 5000, '级别': 2}, '玄武': {'部门': '市场部', '工资': 7000, '级别': 3}, '青龙': {'部门': '科技部', '工资': 5000, '级别': 2}, '白虎': {'部门': '市场部', '工资': 7000, '级别': 2}}

八、数据容器的分类

1.是否支持下标索引

（1）支持：列表、元组、字符串——序列类型
（2）不支持：集合、字典——非序列类型

2.是否支持重复元素：

（1）支持：列表、元组、字符串——序列类型
（2）不支持：集合、字典——非序列类型

3.是否可以修改

（1）支持：列表、集合、字典
（2）不支持：元组、字符串

九、数据容器的通用操作

my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5,}

1.遍历

（1）5类数据容器都支持for循环遍历
（2）列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引while）

2.统计容器元素个数

len(容器)

# 容器的长度
print(f"列表 的长度为：{len(my_list)}")
print(f"元组 的长度为：{len(my_tuple)}")
print(f"字符串的长度为：{len(my_str)}")
print(f"集合 的长度为：{len(my_set)}")
print(f"字典 的长度为：{len(my_dict)}")
# 结果：
# 列表 的长度为：5
# 元组 的长度为：5
# 字符串的长度为：7
# 集合 的长度为：5
# 字典 的长度为：5

3.统计容器最大（小）元素

max(容器)
min(容器)

# 容器的最大元素
print(f"列表 的最大元素是：{max(my_list)}")
print(f"元组 的最大元素是：{max(my_tuple)}")
print(f"字符串的最大元素是:{max(my_str)}")
print(f"集合 的最大元素是：{max(my_set)}")
print(f"字典 的最大元素是：{max(my_dict)}")
# 结果：
# 列表 的最大元素是：5
# 元组 的最大元素是：5
# 字符串的最大元素是:g
# 集合 的最大元素是：5
# 字典 的最大元素是：key5
#
# 容器的最小元素
print(f"列表 的最小元素是：{min(my_list)}")
print(f"元组 的最小元素是：{min(my_tuple)}")
print(f"字符串的最小元素是:{min(my_str)}")
print(f"集合 的最小元素是：{min(my_set)}")
print(f"字典 的最小元素是：{min(my_dict)}")
# 结果：
# 列表 的最小元素是：1
# 元组 的最小元素是：1
# 字符串的最小元素是:a
# 集合 的最小元素是：1
# 字典 的最小元素是：key1

小技巧：shift + alt + 鼠标拖动——将选中的内容全部替换为所输入的数值

4.将指定容器转换为列表

                 list(容器)
                字符串转列表是将字符串中每一个元素分别取出来作为列表的元素
                字典转列表会将value的值都抛弃掉，只留key的值

# 容器转列表
print(f"列表转 列表的结果是：{list(my_list)}")
print(f"元组转 列表的结果是：{list(my_tuple)}")
print(f"字符串转列表的结果是：{list(my_str)}")
print(f"集合转 列表的结果是：{list(my_set)}")
print(f"字典转 列表的结果是：{list(my_dict)}")
# 结果：
# 列表转 列表的结果是：[1, 2, 3, 4, 5]
# 元组转 列表的结果是：[1, 2, 3, 4, 5]
# 字符串转列表的结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 集合转 列表的结果是：[1, 2, 3, 4, 5]
# 字典转 列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']

5.将指定容器转换为元组

tuple(容器)
字符串和字典的转换同列表

# 容器转元组
print(f"列表转 元组的结果是：{tuple(my_list)}")
print(f"元组转 元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组的结果是：{tuple(my_str)}")
print(f"集合转 元组的结果是：{tuple(my_set)}")
print(f"字典转 元组的结果是：{tuple(my_dict)}")
# 结果：列表转 元组的结果是：(1, 2, 3, 4, 5)
# 元组转 元组的结果是：(1, 2, 3, 4, 5)
# 字符串转元组的结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
# 集合转 元组的结果是：(1, 2, 3, 4, 5)
# 字典转 元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')

6.将指定容器转换为字符串

str(容器)
字典转字符串时，所有元素都会保留

# 容器转字符串
print(f"列表转 字符串的结果是：{str(my_list)}")
print(f"元组转 字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串的结果是：{str(my_str)}")
print(f"集合转 字符串的结果是：{str(my_set)}")
print(f"字典转 字符串的结果是：{str(my_dict)}")
# 结果：
# 列表转 字符串的结果是：[1, 2, 3, 4, 5]
# 元组转 字符串的结果是：(1, 2, 3, 4, 5)
# 字符串转字符串的结果是：abcdefg
# 集合转 字符串的结果是：{1, 2, 3, 4, 5}
# 字典转 字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

7.将指定容器转换为集合

set(容器)
字符串和字典的转换同列表
【注意】：对于转换成字典，有函数：dict()，但是转换要求元素是键值对。

# 容器转集合
print(f"列表转 集合的结果是：{set(my_list)}")
print(f"元组转 集合的结果是：{set(my_tuple)}")
print(f"字符串转集合的结果是：{set(my_str)}")
print(f"集合转 集合的结果是：{set(my_set)}")
print(f"字典转 集合的结果是：{set(my_dict)}")
# 结果：
# 列表转 集合的结果是：{1, 2, 3, 4, 5}
# 元组转 集合的结果是：{1, 2, 3, 4, 5}
# 字符串转集合的结果是：{'a', 'e', 'c', 'f', 'd', 'b', 'g'}
# 集合转 集合的结果是：{1, 2, 3, 4, 5}
# 字典转 集合的结果是：{'key5', 'key3', 'key4', 'key1', 'key2'}

8.排序

                sorted(容器,[reverse = True])
                        reverse默认等于False：从小到大
                        reverse = True：从大到小

# 容器的排序
my_list = [2,3,5,1,4]
my_tuple = (2,3,5,1,4)
my_str = "acbgedf"
my_set = {2,3,5,1,4}
my_dict = {"key3":3,"key4":4,"key1":1,"key2":2,"key5":5,}

print(f"列表 对象排序的结果是：{sorted(my_list)}")
print(f"元组 对象排序的结果是：{sorted(my_tuple)}")
print(f"字符串对象排序的结果是：{sorted(my_str)}")
print(f"集合 对象排序的结果是：{sorted(my_set)}")
print(f"字典 对象排序的结果是：{sorted(my_dict)}")
# 结果：
# 列表 对象排序的结果是：[1, 2, 3, 4, 5]
# 元组 对象排序的结果是：[1, 2, 3, 4, 5]
# 字符串对象排序的结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
# 集合 对象排序的结果是：[1, 2, 3, 4, 5]
# 字典 对象排序的结果是：['key1', 'key2', 'key3', 'key4', 'key5']

print(f"列表 对象反向排序的结果是：{sorted(my_list,reverse=True)}")
print(f"元组 对象反向排序的结果是：{sorted(my_tuple,reverse=True)}")
print(f"字符串对象反向排序的结果是：{sorted(my_str,reverse=True)}")
print(f"集合 对象反向排序的结果是：{sorted(my_set,reverse=True)}")
print(f"字典 对象反向排序的结果是：{sorted(my_dict,reverse=True)}")
# 结果：
# 列表 对象反向排序的结果是：[5, 4, 3, 2, 1]
# 元组 对象反向排序的结果是：[5, 4, 3, 2, 1]
# 字符串对象反向排序的结果是：['g', 'f', 'e', 'd', 'c', 'b', 'a']
# 集合 对象反向排序的结果是：[5, 4, 3, 2, 1]
# 字典 对象反向排序的结果是：['key5', 'key4', 'key3', 'key2', 'key1']

【注意】：排序的结果通通会变成列表对象
字典的排序会丢失value值

十、字符串大小的比较

1.基本知识点

（1）在程序中，字符串所用的所有字符，比如：大小写英文、数字和特殊符号（!、\、|、@、#和空格）等，都有对应的SACII码表值

（2）每个字符对应一个数字码值
（3）字符串的比较基于数字的码值大小进行比较

2.字符串的比较

从头到尾，一位一位的按位进行比较，只要其中一位大，整体就大，比较结束

# abc与abd比较
print("abc"<"abd")  # 结果是：True
# a与ab比较
print("a"<"ab")  # 结果是：True
# a与A比较
print("a"<"A")  # 结果是：False
# key1与key2比较
print("key1"<"key2")  # 结果是：True