Python容器

容器

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

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

列表

列表类型是数据容器的一类，一次可以存储多个数据，且可以为不同的数据类型，支持嵌套。

列表内的每一个数据，称之为元素，以 [] 作为标识，列表内每一个元素之间用 ， d逗号隔开。

列表的定义

基础语法

# 字面量
[元素1，元素2，元素3，元素4，...]

# 定义变量
变量名称 = [元素1，元素2，元素3，元素4，...]

# 定义空列表
变量名称 = []
变量名称 = list()

# 定义一个列表 list
my_list = ['java','python','go']
print(my_list)
print(type(my_list))
# 元素类型不受限制
my_list = ['java',666,True]
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [[1,2,3],[5,6]]
print(my_list)
print(type(my_list))

列表的下标索引

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

下标索引从0开始，从前向后。

也有反向索引，也就是从后向前，从-1开始，依次递减。

案例

# 通过下标索引取出对应位置的数据
my_list = ['java','python','go']
# 列表[下标索引]，从前向后从0开始，每次+1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范，如果超出会报错越界
# print(my_list[3])

# 通过下标索引取出数据（倒叙取出）
# 从后向前从-1开始，每次-1
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1,2,3],[5,6]]
print(my_list[1][1])

注意事项

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

列表的查询功能

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

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

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

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError。

语法：列表.index(元素)

ps：index 就是雷彪对象（变量）内置的方法（函数）。

# 查找某元素在列表内的下标索引
index = mylist.index("java")
print(f"java 在列表中的下标索引值是{index}")

# 如果被查找的元素不存在会报错
index = mylist.index("c++")
print(f"java 在列表中的下标索引值是{index}")

列表的修改功能

修改特定位置（索引）的元素值

语法：列表[下标] = 值

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行 ：重新赋值（修改）。

# 修改特定下标索引的值
mylist[2] = "c++"
print(f"列表修改元素后，结果是{mylist}")

插入元素

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

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

追加元素

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

# 在列表的尾部追加 单个 新元素
mylist.append("JavaScript")
print(f"列表追加元素后，结果是{mylist}")

追加一批元素

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

# 在列表的尾部追加 一批 新元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表追加新的列表后，结果是{mylist}")

删除元素

语法1：del 列表[下标]

语法2：列表.pop(下标)

# 删除指定下标索引的元素（两种方式）
mylist = ["java","python","go"]
# 方式1：del
del mylist[2]
print(f"列表删除元素后，结果是{mylist}")

# 方式2：pop
mylist = ["java","python","go"]
element = mylist.pop(2)
print(f"列表删除元素后，结果是{mylist}，取出的元素是{element}")

删除某元素在列表中的第一个匹配项

语法：列表.remove(元素)

# 删除某元素在列表中的第一个匹配项
mylist = ["java","python","java","go","java"]
mylist.remove("java")
print(f"列表使用remove移除元素后，结果是{mylist}")

清空列表

语法：列表.clear()

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

统计某元素在列表内的数量

语法：列表.count(元素)

# 统计列表内某元素的数量
mylist = ["java","python","java","go","java"]
count = mylist.count("java")
print(f"列表中 java 的数量为{count}")

统计容器内有多少个元素

语法：len(列表)

# 统计列表中全部的元素数量
mylist = ["java","python","java","go","java"]
count = len(mylist)
print(f"列表中的元素数量一共有{count}")

列表的遍历

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

while 循环

def list_while_func():
    """
    使用 while 循环遍历列表的演示函数
    :return:
    """
    mylist = ["java","python","go"]
    # 循环控制变量通过下标索引来控制，默认0
    index = 0
    # 循环条件：下标索引变量 < 列表的元素数量
    while index<len(mylist):
        # 通过index 变量取出对应下标的元素
        element = mylist[index]
        print(f"列表的元素：{element}")
        # 每一次循环将下标索引变量+1
        index += 1

for 循环

def list_for_func():
    """
    使用 for 循环遍历列表的演示函数
    :return:
    """
    mylist = ["java", "python", "go"]
    # for 临时变量 in 数据容器
    for element in mylist:
        print(f"列表的元素：{element}")

两者对比

在循环控制上

• while 循环可以自定循环条件，并自行控制
• for 循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上

• while 循环可以通过条件控制做到无限循环
• for 循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上

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

元组

为什么需要元组

列表是可以修改的，如果先要传递的信息，不被篡改，列表就不合适了。

元组

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

​ 元组一旦定义完成，就不可修改。

当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组
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 = ("java", "python", "go")
idx = t6.index("java")
print(f"java在元组t6的下标是{idx}")

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

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

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

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

# 修改元組內容（元組不能修改內容，会出bug）
# t8[0] = "css"

# 虽然不能修改元组的内容，但是可以修改其内部list的内部元素
t9 = (1,2,["java","go"])
print(f"t9的内容是：{t9}")
t9[2][1] = "python"
print(f"t9的内容是：{t9}")

特点

• 和 list 基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。
• 支持 for 循环。

字符串

字符串看起来并不像列表、元组那样，一看就是存放了许多数据的容器。

但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

字符串也可以通过下标进行访问，从前向后，下标从0开始，从后向前，下标从-1开始。

my_str = "My name is qz"
# 通过下标索引取值
value = my_str[3]
print(f"字符串的第四个元素是：{value}")
# 从后向前取
value1 = my_str[-10]
print(f"字符串的第四个元素是：{value1}")

同元组一样，字符串是一个无法修改的数据容器。

所以无法完成修改指定下标的字符，无法移除特定下标的字符，无法追加字符。

如果必须要做，只能得到一个新的字符串。

常用操作

查找特定字符串的下标索引值

语法：字符串.index(字符串)

# index 方法
idx = my_str.index("name")
print(f"name在字符串中的下标为：{idx}")

字符串的替换

语法：字符串.replace(字符串1，字符串2)

功能：将字符串内的全部：字符串1，替换成字符串2

注意：不是修改字符串本身，而是得到了一个新字符串

# replace 方法
new_my_str = my_str.replace("qz","zy")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")

字符串的分割

语法：字符串.split(分割字符串)

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象。

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

字符串的规整操作

去前后空格

语法：字符串.strip()

去前后指定字符串

语法：字符串.strip(字符串)

# strip 方法
my_str = "  My name is qz  "
new_my_str = my_str.strip() # 不传入参数，取出首位空格
print(f"将字符串{my_str}进行strip后，结果为{new_my_str}")

my_str = "12My name is qz21"
new_my_str = my_str.strip("21")
print(f"将字符串{my_str}进行strip后，结果为{new_my_str}")

统计字符串字符出现的次数、

语法：字符串.count()

# 统计字符串中某字符串的出现次数，count
my_str = "My name is qz qz"
count = my_str.count("qz")
print(f"字符串{my_str}qz的出现次数为{count}")

统计字符串的长度

语法：len(字符串 )

# 统计字符串的长度,len
my_str = "My name is qz qz"
len = len(my_str)
print(f"字符串{my_str}的长度{count}")

特点

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

数据容器切片

序列是指：内容连续、有序，可以使用下标索引的一类数据容器

列表、元组、字符串均可以视为序列

切片

从一个序列中，取出一个子序列。

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 其实下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长n表示，每次跳过n-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

此操作不会影响序列本身，而是会得到一个新的序列。

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

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

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

# 对 str 进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
res4 = my_str[::-1]  # 等同于将序列反转
print(f"结果4：{res4},类型是：{type(res4)}")

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

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

集合

如果场景中需要对内容做去重处理，列表、元组、字符串就不方便了。

集合最主要的特点就是不支持元素重复（自带去重功能），且内容无序。

定义集合

# 定义集合
my_set = {"java","python","html","javascript","java","python"}
my_set_empty = set()
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")

修改

因为集合是无序的，所以集合不支持下标索引访问。

但是集合和列表一样，是允许修改的。

添加新元素

语法：集合.add(元素)。将指定元素，添加到集合内。

结果：集合本身被修改，添加了新元素。

# 添加新元素
my_set.add("shell")
my_set.add("java")
print(f"my_set添加元素后内容是：{my_set}")

移除元素

语法：集合.remove(元素)，将指定元素，从集合内移除。

结果：集合本身被修改，移除了元素。

# 移除元素
my_set.remove("html")
print(f"my_set移除元素后内容是：{my_set}")

从集合中随机取出元素

语法：集合.pop()，从集合中随机取出一个元素。

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除。

# 随机取出一个元素
element = my_set.pop()
print(f"集合随机取出一个元素为：{element},取出元素后集合为：{my_set}")

清空集合

语法：集合.clear()

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

取两个集合的差集

语法：集合1.difference(集合2)，取出集合1和集合2的差集（集合1有而集合2没有的）。

结果：得到一个新集合，集合1和集合2不变。

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

消除两个集合的差集

语法：集合1.difference_update(集合2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

结果：集合1被修改，集合2不变。

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

两个集合合并

语法：集合1.union(集合2)

功能：将集合1和集合2组合成新集合。

结果：得到新集合，集合1和集合2不变。

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

统计集合元素数量

语法：len(集合)

# 统计集合元素数量
set1 = {1,2,3,4,5}
num = len(set1)
print(f"集合内的元素数量有：{num}")

遍历

集合不支持下标索引，不能用 while 循环，可以使用 for 循环。

# 集合的遍历
set1 = {1,2,3,4,5}
for ele in set1:
    print(f"集合的元素有：{ele}")

特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是虚无存放的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持 for 循环

字典

字典同样使用{}，不过存储的元素是一个个的键值对，字典的键是不允许重复的，如果重复，后面的值会把先前的值覆盖掉。

# 定义字典
my_dict1 = {
    "姓名":"jqz",
    "身高":178,
    "体重":71.5
}
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容为：{my_dict1}，类型是：{type(my_dict1)}")
print(f"字典2的内容为：{my_dict2}，类型是：{type(my_dict1)}")
print(f"字典3的内容为：{my_dict3}，类型是：{type(my_dict1)}")

获取 key 所对应的 value 内容

# 从字典中基于 key 获取value
my_dict1 = {
    "姓名":"jqz",
    "身高":178,
    "体重":71.5
}
name = my_dict1["姓名"]
print(f"姓名为：{name}")

字典的嵌套

字典的 key 和 value 可以是任意数据类型的（key 不可为字典）。

那么就表明字典是可以嵌套的。

# 字典的嵌套
stu_score_dict = {
    "jqz":{
        "语文":97,
        "数学":95,
        "英语":85
    },
    "zy":{
        "语文":92,
        "数学":90,
        "英语":87
    },
    "lg":{
        "语文":96,
        "数学":94,
        "英语":97
    },
}

print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 查看jqz的语文信息
score = stu_score_dict["jqz"]["语文"]
print(f"jqz的语文成绩为：{score}")

注意事项

• 键值对的key和value可以是任意类型（key不可为字典）
• 字典内 key 不允许重复，重复添加等同于覆盖原有数据。
• 不可以通过下标查找，但是可以根据 key 检索 value

常用操作

新增元素

语法：字典[key] = value

结果：字典被修改，新增了元素

# 新增元素
my_dict["班级"] = "信管1902"
print(f"字典经过新增元素后，结果：{my_dict}")

更新元素

语法：字典[key] = value

结果：字典被修改，元素被更新

注意：字典key 不可以重复，所以对已存在的 key 执行上述操作， 就是更新 value 值。

# 更新元素
my_dict["身高"] = 179
print(f"字典经过更新元素后，结果：{my_dict}")

删除元素

语法：字典.pop(key)

结果：获得指定 key 的 value，同时字典被修改，指定 key 的数据被删除。

# 删除元素
my_class = my_dict.pop("班级")
print(f"字典经过删除元素后，结果：{my_dict}，班级为：{my_class}")

清空字典

语法：字典.clear()

结果：字典被修改，元素被清空

# 清空元素
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

获取所有的key

语法：字典.keys()

作用：可用于for循环遍历字典

# 获取全部的key
my_dict = {
    "姓名":"jqz",
    "身高":178,
    "体重":71.5
}
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"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

计算字典内元素数量

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

特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过key获取到Value，Key不可重复（重复会覆盖）
• 不支持索引访问
• 可以修改（增加或更新元素）
• 支持for循环，不支持while循环

分类

是否支持下标索引

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

是否支持重复元素

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

是否可以修改

• 支持：列表、集合、字典
• 不支持：元组、字符串

使用场景

列表

一批数据，可修改、可重复的存储场景

元组

一批数据，不可修改、可重复的存储场景

字符串

一串字符串的存储场景

集合

一批数据，去重存储的场景

字典

一批数据，可用key检索value的存储场景

通用操作

遍历

五类数据容器都支持for循环遍历。

列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

统计

统计容器元素个数

len(容器)

统计容器的最大元素

max(容器)

统计容器的最小元素

min(容器)

转换

list(容器)：将给定容器转换为列表

str(容器)：将给定容器转换为字符串

tuple(容器)：将给定容器转换为元组

set(容器)：将给定容器转换为集合

排序

通用排序功能，排序结果转换为列表

sorted(容器，[reverse=True])

将给定容器进行排序，默认为正序，如果需要倒叙，加入reverse=True

# 准备列表
my_list = [["a",33],["b",2],["c",11]]

# 排序，基于带名函数
def choose_sort_key(element):
    return element[1]
my_list.sort(key=choose_sort_key,reverse=True)
print(my_list)
# 排序，基于匿名函数
my_list.sort(key=lambda element:element[1],reverse=False)
print(my_list)