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循环

通用操作

遍历

五类数据容器都支持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)