六、Python数据容器

1. 数据容器入门

1.什么是数据容器?

一种可以存储多个元素的Python数据类型

2.Python有哪些数据容器?

list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

它们各有特点，但都满足可容纳多个元素的特性

2. 数据容器：list（列表）

"""
数据容器之：list列表
"""
# 定义一个列表 list
my_list = ["zhang","123","True",[1,2,3]]
print(my_list)
print(type(my_list))

1.列表的定义语法

[元素1, 元素2,元素3,.......]

2.什么是元素?

数据容器内的每一份数据，都称之为元素

3.元素的类型有限制吗?

元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

*列表的下标索引

my_list = [[1,2,3],[4,5,6]]
print(my_list[0][-1])

1.列表的下标索引是什么?

列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增

从后向前的方向，编号从-1开始递减

2.如何通过下标索引取出对应位置的元素呢?

列表[下标]，即可取出

3.下标索引的注意事项:

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

3. 列表的常用操作

列表的查询功能（方法）

回忆：

函数是一个封装的代码单元，可以提供特定功能。

在python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

# 函数
def add(x, y):
    return x + y

# 方法
class Student:

    def add(self, x, y):
        return x + y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同

函数的使用:

num = add(1，2)

方法的使用：

student = Student()
num = student.add(1，2）

列表的方法-总览

编号	使用方法	作用
1	列表.append(元素)	向列表中途加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标，元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标，找不到报错ValueError
10	len(列表)	统计容器内有多少元素

"""
List列表的常用操作
"""
my_list = ["zhang","zheng","python"]
# 1.1 查找某元素在列表内的下标索引
index = my_list.index("python")
print(f"python在列表中的下标索引值是：{index}")
# 1.2 如果被查找的元素不存在，会报错
index = my_list.index("hello")
print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
my_list[0] = "zhangzheng"
print(f"列表被修改元素值后，结果是：{my_list}")

#在指定下标位置插入新元素
my_list.insert(1, "best")
print(f"列表插入元素后，结果是：{my_list}")

# 4. 在列表的尾部，追加“”“单个”“”新元素
my_list.append("one last kiss")
print(f"列表在尾部追加了单个元素后，结果是：{my_list}")

# 5. 在列表的尾部追加“”“一批”“”新元素
my_list2 = [1,2,3]
my_list.extend(my_list2)
print(f"列表在追加了一个新的列表后，结果是：{my_list}")

# 6. 删除指定下标索引的元素（两种方式）
my_list = ["zhang","zheng","python"]

# 6.1 方法1： del 列表[下标]
del my_list[2]
print(f"列表删除元素后的结果是：{my_list}")
# 6.2 方法2： 列表.pop（下标）
my_list = ["zhang","zheng","python"]
element = my_list.pop[2]
print(f"通过pop方法取出元素后列表内容：{mylist}，取出的元素是：{element}")

# 7. 删除某元素在列表中第一个匹配项
my_list = ["zhang","zheng","zhang","zheng","python"]
my_list.remove("zhang")
print(f"通过remove方法移除后，列表的结果是：{my_list}")

# 8. 清空列表
my_list.clear()
print(f"列表被清空了，结果是：{my_list}")

# 9. 统计某元素在列表内的数量
my_list = ["zhang","zheng","zhang","zheng","python"]
count = my_list.count("zhang")
print(f"列表中zhang的数量是：{count}")

# 10. 统计列表中全部的元素数量
my_list = ["zhang","zheng","zhang","zheng","python"]
count = len(my_list)
print(f"列表的元素数量总共有：{count}个")

列表的方法-说明

• 功能方法非常多，同学们不需要硬记下来

• 学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术除了经常用的，大多数是记忆不下来的。

• 我们要做的是，有一个模糊印象，知晓有这样的用法，需要的时候，随时资料即可

列表的特点

• 经过上述对列表的学习，可以总结出列表有如下特点:可以容纳多个元素(上限为2*63-1、9223372036854775807个)

• 可以容纳不同类型的元素（混装)

• 数据是有序存储的(有下标序号)

• 允许重复数据存在

• 可以修改(增加或制除元素等)

列表的常用操作练习

有一个列表，内容是:[21,25,21,23,22,20]，记录的是一批学生的年龄

请通过列表的功能(方法)，对其进行：

1.定义这个列表，并用变量接收它

2.追加一个数字31，到列表的尾部

3.追加一个新列表[29,33,30]，到列表的尾部

4.取出第一个元素(应是: 21)

5.取出最后一个元素(应是: 30)

6.查找元素31，在列表中的下标位置

"""
List常用操作的练习
"""

#1. 定义这个列表，并用变量接收它，内容是：[21，25，21，23，22，20]
mylist = [21, 25, 21, 23, 22, 20]

# 2. 追加一个数字31，到列表的尾部
mylist.append(31)

# 3. 追加一个新列表[29，33，30]，到列表的尾部
mylist.extend([29, 33, 30])

# 4. 取出第一个元素（应是30）
num1 = mylist[0]
print(f"从列表中取出来第一个元素，应该是21，实际上是：{num1}")

# 5. 取出最后一个元素（应是30）
num2 = mylist[-1]
print(f"从列表中取出最后一个元素，应该是30，实际上是：{num2}")

# 6. 查找元素31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置是：{index}")
print(f"最后的列表内容是：{mylist}")

4. list（列表）的遍历

1.什么是遍历?

将容器内的元素依次取出，并处理，称之为遍历操作

2.如何遍历列表的元素?

可以使用while或for循环

3.for循环的语法:

for 临时变量 in 数据容器:

对临时变量进行处理

4.for循环和while对比

• for循环更简单，while更灵活

• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

while循环

"""
对list列表的循环，使用while和for循环两种方式
"""

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = ["zhang","zheng","python"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件： 下标索引变量 < 列表的元素数量

    #定义一个变量用来标记列表的下标
    index = 0           #初始值为0
    while index < len(my_list):
        #通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")

        # 至关重要，将循环变量（index）每一次循环+1
        index += 1

list_while_func()

for循环

#
def list_for_func():
    """
    使用for循环遍历列表内的演示函数
    :return: None
    """
    my_list = [1, 2, 3, 4, 5]
    #for 临时变量 in 数据容器：
    for element in my_list:
        print(f"列表的元素有：{element}")

list_for_func()

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同:

在循环控制上:

• while循环可以自定循环条件并自行控制

• far循环不可以自定循环条件,只可以一个个从容器内取出数据

在无限循环上:

• whle简环可以通过条件控制做到无限循环

• for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上:

• whle循环适用于任何想要循环的场景

• for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

5. 数据容器：tuple（元组）

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")

# 定义单个元素的元组
t4 = ("Hello,")
print(f"t4的类型是：{type(t4)},内容是：{t4}")

# 元组的嵌套
t5 = ((1, 2, 3),(4, 5, 6))
print(f"t5的类型是：{type(t5)},内容是：{t5}")

# 下标索引取内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是： {num}")

# 元组的操作：index查找方法
t6 = ("zhang","zheng","python")
index = t6.index("zheng")
print(f"在元组t6中查找zheng的下标是：{index}")

# 元组的操作：count统计方法
t7 = ("zhang","zheng","zheng","zheng","python")
num = t7.count("zheng")
print(f"在元组t7中统计zheng的数量有：{num}个")

# 元组的操作：len函数统计元组数量
t8 = ("zhang","zheng","zheng","zheng","python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")

#元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"元组的元素有：{element}")

# 修改元组内列表的内容
t9 = (1, 2, ["zhang","zheng"])
print(f"t9的内容是：{t9}")
t9[2][0] = "python"
print(f"t9的内容是：{t9}")

1.元组的定义方式:

• (元素,元素,元素,......)

2.元组的操作方法:

1. index() 查找某个数据，如果数据存在返图对应的下标，否则报错

2. count() 统计某个数据在当前元组出现的次数

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

3.元组的注意事项

• 不可修改内容(可以修改内部list的内部元素)

4.元组的特点:

• 和list基本相同（有序、任意数量元素、允许重复元素)，唯一不同在于不可修改

• 支持for循环

6. 数据容器：str（字符串）

字符串为什么被称之为数据容器呢？

• 字符串可以看作是字符的容器，支持下标索引等特性

"""
以数据容器的角色，字符串的相关操作
"""
my_str = "zhang zheng python"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"下标为2的元素是：{value}，下表为-16的元素是：{value2}")

# index方法
value = my_str.index("zheng")
print(f"zheng的下标索引值是：{value}")

# replace方法
new_my_str = my_str.replace("zh","Z")
print(f"将字符{my_str},\，替换后得到{new_my_str}")

# split方法
my_str = "zhang zheng python"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是：{type(my_str_list)}")

# strip方法
my_str = "    zhang zheng python    "
new_my_str = my_str.strip()     #不传入参数，去除首位空格
print(f"字符串{my_str}被strip(),结果：{new_my_str}")

my_str = "121zhang zheng python121"
new_my_str = my_str.strip("121")
print(f"字符串{my_str}被strip('121'),结果：{new_my_str}")

# 统计字符串中某字符串的出现次数，count
my_str = "zhang zheng python"
count = my_str.count("zh")
print(f"字符串{my_str}中zh出现的次数是：{count}")

# 统计字符串的长度，len()
num = len(my_str)
print(f"{my_str}的长度是：{num}")

字符串的操作方法

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串index(字符串)	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1,字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔，不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

字符串的特点

作为数据容器，字符串有如下特点:

• 只可以存储字符串长度任意(取决于内存大小)

• 支持下标索引

• 允许重复字符串存在

• 不可以修改(增加或删除元素等 )

• 支持for循环

7. 数据容器的切片

"""
 对序列进行切片操作
"""

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]       # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_list[::-1]
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到2结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:2:-1]
print(f"结果5：{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

1.什么是序列?

内容连续、有序，支持下标索引的一类数据容器

2.哪些数据容器可以视为序列?

列表、元组、字符串

3.序列如何做切片

序列[起始:结束:步长]

• 起始可以省略，省略从头开始

• 结束可以省略，省略到尾结束

• 步长可以省略，省略步长为1(可以为负数，表示倒序执行)

序列的切片练习

"""
序列的切片练习
"""
my_str = "万过月薪，员序程马黑来，nohtyP学"

# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式1结果：{result1}")

# 切片取出然后倒序
result2 = my_str[5:10][::-1]
print(f"方式2结果：{result2}")

# spilt分隔“，”  replace替换“来”为空，再倒序字符串
result3 = my_str.split("，")[1].replace("来","")[::-1]
print(f"方式3结果：{result3}")

8. 数据容器：set（集合）

1.集合有哪些特点:

• 集合内不允许重复元素（去重）

• 集合内元素是无序的（不支持下标索引)

2.集合的定义方式:

[元素,元素,...., 元素]

3.集合的常用操作

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.femove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.lclear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变
8	len(集合)	得到一个整数,记录了集合的元素数量

4.如何遍历集合元素

• 可以使用for循环进行变量

• 不可以使用while循环，因为不支持下标索引

5.集合的特点

• 可以容纳多个数据

• 可以容纳不同类型的数据 (混装)

• 数据是无序存储的(不支持下标索引)

• 不允许重复数据存在

• 可以修改(增加或删除元素等)

• 支持for循环

# 定义集合
my_set = {"zhangyi","zhanger","zhangsan","zhangsan","zhanger"}
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")

# 添加新元素
my_set.add("python")
print(f"添加新元素的结果是{my_set}")

# 移除元素
my_set.remove("zhangsan")
print(f"移除zhangsan后的结果是：{my_set}")

# 随机取出一个元素
my_set = {"zhangyi","zhanger","zhangsan"}
element = my_set.pop()
print(f"集合被取出元素是{element},取出元素后的集合是{my_set}")

# 清空集合
my_set.clear()
print(f"集合被清空后，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)

# 消除两个集合的差集(相同的元素)
set1.difference_update(set2)
print(set1)
print(set2)

# 2个集合合并
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)

# 统计集合的元素数量
num = len(set3)
print(num)

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5, 6}
for element in set1:
    print(f"集合的元素有：{element}")

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

1.为什么使用字典

字典可以提供基于Key检索Value的场景实现

就像查字典一样

2.字典的定义语法

# 定义字典字面量
{key: value, key: value, ……，key: value}

# 定义字典变量
my_diect = {key: value, key: value, ……，key: value}

# 定义空字典
my_dict = {}        # 空字典定义方式2
my_dict = dict()    # 空字典定义方式1

3.字典的注意事项

• 键值对的Key和Value可以是任意类型 (Key不可为字典)

• 字典内Key不允许重复，重复添加等同于覆盖原有数据

"""
数据容器字典的定义
"""

# 定义字典
my_dict = {"zhang":1, "zheng":2, "python":3}
print(f"字典内容是：{my_dict}，类型是：{type(my_dict)}")

# 从字典中基于key获取Value
my_dict = {"zhang1":1, "zhang2":2, "zhang3":3}
score = my_dict["zhang1"]
print(f"zhang1的值是：{score}")

# 定义嵌套字典
stu_score_dict = {
    "zhang1":{
        "chinese":11,
        "engish":22,
        "math":33
    }, "zhang2":{
        "chinese": 44,
        "engish": 55,
        "math": 66
    }, "zhang3":{
        "chinese": 77,
        "engish": 88,
        "math": 99
    }
}
print(stu_score_dict)

# 从嵌套字典中获取数据
score = stu_score_dict["zhang1"]["chinese"]
print(f"zhang1的chinese成绩是：{score}")     # 查看zhang1的chinese成绩

1. 字典的常用操作

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key]= Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内制除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

2. 操作注意

• 新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新(Key不可重复)

3. 字典的特点

• 可以容纳多个数据

• 可以容纳不同类型的数据

• 每一份数据是KeyValue键值对

• 可以通过Key获取到Value，Key不可重复 (重复会覆盖)

• 不支持下标索引

• 可以修改(增加或删除更新元素等 )

• 支持for循环，不支持while循环

"""
字典的常用操作
"""
my_dict = {"zhang1":77, "zhang2":88, "zhang3":99}

# 新增/更新元素
my_dict["zhang4"] = 66
print(my_dict)

# 删除元素
score = my_dict.pop("zhang3")
print(my_dict,score)

# 清空元素，clear
my_dict.clear()
print(my_dict)

# 获取全部的key
my_dict = {"zhang1":77, "zhang2":88, "zhang3":99}
keys = my_dict.keys()
print(f"字典的全部key是:{keys}")

# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是：{key}")
    print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量，len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

4. 字典的综合练习

"""
字典的综合练习，升值加薪，对所有级别为1的员工，级别上升1级，薪水增加1000元
"""

# 组织字典记录数据
info_dict = {
    "王":{
        "部门":"科技部",
        "工资":3000,
        "级别":1
    },
    "周":{
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林":{
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张":{
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘":{
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}

print(f"员工在升级加薪之前的结果：{info_dict}")

# for循环遍历字典
for name in info_dict:
    # if条件判断符合条件的员工
    if info_dict[name]["级别"] == 1:
        # 升值加薪操作
        # 获取到员工的信息字典
        employee_info_dict = info_dict[name]
        # 修改员工的信息
        employee_info_dict["级别"] = 2    # 级别+1
        employee_info_dict["工资"] += 1000    # 工资+1000
        # 将员工的信息更新到in_dict
        info_dict[name] = employee_info_dict

# 输出结果
print(f"对员工进行升级加薪后的结果是：{info_dict}")

10. 数据容器对比总结

11. 数据容器的通用操作

12. 拓展-字符串大小的比较方式

1.字符串如何比较

从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

2.单个字符之间如何确定大小?

通过ASCII码表，确定字符对应的码值数字来确定大小