五、python的数据容器--附代码案例

5.1 导入

为什么要学习数据容器：一个变量容纳多个数据，解决变量批量定义、存储、处理。
定义：容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
分类：数据容器根据特点的不同，是否支持重复元素、是否可以修改、是否有序，等分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

5.2 列表

5.2.1 定义

以 [ ] 作为标识，容器内每一个元素之间用英文逗号隔开。元素可以为不同的数据类型，所以也支持嵌套列表。
语法：变量名 = [元素1,元素2...元素n]
定义空列表语法1：变量名 = [ ]
定义空列表语法2：变量名 = list()

5.2.2 特点

①可以容纳多个元素（上限为2**63-1、9223372036854775807个）；
②可以容纳不同类型的元素（混装）；
③数据是有序存储的（有下标索引）；
④允许重复数据存在；
⑤可以增删改操作；
⑥支持while循环和for循环遍历。

5.2.3 下标索引

可以通过列表的下标索引从列表中取出特定位置的数据。

5.2.3.1 正向索引

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增。

5.2.3.2 反向索引

如图，列表中的每一个元素，都有其位置下标索引，从后向前的方向：从-1开始，依次递减）

5.2.3.3 嵌套列表的索引

如果列表是嵌套的列表，同样支持下标索引。也支持同时正向索引和反向索引。

# 定义一个列表 list，可以为不同的数据类型，支持嵌套
my_list = ['list', [2, 3, 5], True, 666]
# 打印数据：['list', [2, 3, 5], True, 666]
print(my_list)
# 打印类型：
print(type(my_list))
# 正向索引取出数据
print(my_list[0])	# list
print(my_list[1])	# [2, 3, 5]
print(my_list[2])	# True
print(my_list[3])	# 666
# error，下标索引越界
# print(my_list[4])
# 正向索引取出嵌套列表的元素
print(my_list[1][0])	# 2
print(my_list[1][1])	# 3
print(my_list[1][2])	# 5
# 反向索引取出数据
print(my_list[-1])	# 666
print(my_list[-2])	# True
print(my_list[-3])	# [2, 3, 5]
print(my_list[-4])	# list
# 反向索引取出嵌套列表的元素
print(my_list[-3][-1])	# 5
print(my_list[-3][-2])	# 3
print(my_list[-3][-3])	# 2
# 交叉索引取出嵌套列表的元素
print(my_list[-3][0])   # 等价于print(my_list[-3][-3])
print(my_list[-3][1])   # 等价于print(my_list[-3][-2])
print(my_list[-3][2])   # 等价于print(my_list[-3][-1])

5.2.4 常用操作

功能方法非常多，不需要硬记下来。学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术。除了经常用的，大多数是记忆不下来的。
因此有一个模糊印象，知晓有这样的用法即可。需要的时候，随时查阅资料即可。

5.2.4.1 列表的查询功能

语法：列表.index(要查找的元素)
功能：查找指定元素在列表的下标，如果找不到，报错ValueError，提示该元不在列表中。

5.2.4.2 列表的修改功能

语法：列表[下标] = 值
功能：直接对指定下标的值进行重新赋值（修改）。

5.2.4.3 列表的插入功能

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

5.2.4.4 列表的追加功能

5.2.4.4.1 单个元素的追加

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

5.2.4.4.2 多个元素的追加

语法：列表.extend(数据容器)
功能：将指定的多个元素，追加到列表的尾部。

5.2.4.5 列表的删除功能

语法1：del 列表[下标]
语法2：列表.pop(下标)
功能：删除指定下标索引的元素。
语法：列表.remove(元素)
功能：删除某元素在列表中的第一个匹配项。

5.2.4.6 列表的排序功能

问题：在5.8.2.5里有sorted函数，可以对数据容器进行排序，但只能按ASCII码值或者数字大小进行排序，不能自定义排序规则去排序。sort方法可以解决这个问题。
语法：列表.sort(key=选择排序依据的函数, reverse=True|False)
说明：参数key是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据；参数reverse是否反转排序结果，True表示降序，False表示升序。
功能：将给定列表按自定义规则进行排序，不产生新的列表。

# 列表里面嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素的数字
# sorted函数不适用，是因为sorted方法只能排序ASCII值和数字，不能对数据容器进行排序，但可以用sort方法
my_list = [["a", 33], ["b", 55], ["c", 11]]


def my_list_sort(element):      # 把每个元素都进来，由函数来决定用元素的哪个部分来排序
    return element[1]           # 内层列表的第二个元素的数字作为依据来排序，就是下标1，直接返回排序依据即可


my_list.sort(key=my_list_sort, reverse=True)
print(my_list)                  # [["b", 55], ["a", 33], ["c", 11]]

或者使用匿名函数

# 列表里面嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素的数字
# sorted函数不适用，是因为sorted方法只能排序ASCII值和数字，不能对数据容器进行排序，但可以用sort方法
my_list = [["a", 33], ["b", 55], ["c", 11]]

my_list.sort(key=lambda element : element[1], reverse=True)
print(my_list)                  # [["b", 55], ["a", 33], ["c", 11]]

5.2.4.7 列表的清空功能

语法：列表.clear()
功能：清空列表内容。

5.2.4.8 列表的统计功能

语法：列表.count(元素)
功能：统计某元素在列表内的数量。
语法：len(列表)
功能：统计列表中全部的元素数量。

mylist = ['list', [2, 3, 5], True, 666]
# 查找指定元素在列表的下标
index = mylist.index("list")
print(f"list在列表中的下标索引值是：{index}")    # 0
# 如果找不到，报错ValueError
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")
# 对指定下标的值进行修改
mylist[0] = 3.14
print(f"列表被修改元素值后，结果是：{mylist}")       # [3.14, [2, 3, 5], True, 666]
# 在指定的下标位置，插入指定的元素
mylist.insert(1, "list")
print(f"列表插入元素后，结果是：{mylist}")          # [3.14, 'list', [2, 3, 5], True, 666]
# 将指定的单个元素，追加到列表的尾部
mylist.append("列表")
print(f"列表在追加了元素后，结果是：{mylist}")       # [3.14, 'list', [2, 3, 5], True, 666, '列表']
# 将指定的多个元素，追加到列表的尾部
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}") # [3.14, 'list', [2, 3, 5], True, 666, '列表', 1, 2, 3]
# 删除指定下标索引的元素
del mylist[-1]
print(f"列表删除元素后结果是：{mylist}")            # [3.14, 'list', [2, 3, 5], True, 666, '列表', 1, 2]
element = mylist.pop(-1)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")   # [3.14, 'list', [2, 3, 5], True, 666, '列表', 1], 取出的元素是：2
# 删除某元素在列表中的第一个匹配项
mylist = ["element1", "element2", "element1", "element2", "element3"]
mylist.remove("element2")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")   # ['element1', 'element1', 'element2', 'element3']
# 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")                  # []
# 统计列表内某元素的数量
mylist = ["element1", "element2", "element1", "element2", "element3"]
count = mylist.count("element1")
print(f"列表中element1的数量是：{count}")                # 2
# 统计列表中全部的元素数量
mylist = ["element1", "element2", "element1", "element2", "element3"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")                 # 5

5.2.5 遍历

利用循环对列表进行遍历。

5.2.5.1 while循环

# 使用while循环遍历列表的演示函数
def list_while_func():
    mylist = ["while", "循环", "遍历"]
    index = 0
    while index < len(mylist):
        element = mylist[index]
        print(f"列表的元素：{element}")
        index += 1

if __name__ == '__main__':
    list_while_func()

6.2.5.2 for循环

# 使用for循环遍历列表的演示函数
def list_for_func():
    mylist = [1, 2, 3, 4, 5]
    for element in mylist:
        print(f"列表的元素有：{element}")

if __name__ == '__main__':
    list_for_func()

while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
while循环可以自定循环条件，并自行控制；
for循环不可以自定循环条件，只可以一个个从容器内取出数据。
在无限循环上：
while循环可以通过条件控制做到无限循环；
for循环理论上不可以，因为被遍历的容器容量不是无限的。
在使用场景上：
while循环适用于任何想要循环的场景，不支持集合的遍历；
for循环适用于遍历数据容器的场景或简单的固定次数循环场景，支持集合的遍历。

5.3 元组

5.3.1 定义

以 ( ) 作为标识，容器内每一个元素之间用英文逗号隔开，数据可以是不同的数据类型。
语法：变量名 = (元素1,元素2...元素n)
定义空元组语法1：变量名 = ()
定义空元组语法2：变量名 = tuple()

5.3.2 特点

元组可以认为是只读的列表。元组一旦定义完成，就不可修改。
①可以容纳多个元素；
②可以容纳不同类型的元素（混装）；
③数据是有序存储的（有下标索引）；
④允许重复数据存在；
⑤不可以增删改操作；
⑥支持while循环和for循环遍历。

# 定义元组
t1 = ('tuple', [2, 3, 5], True, 666)
# 定义空元组
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")   # t1的类型是：, 内容是：('tuple', [2, 3, 5], True, 666)
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")   # t2的类型是：, 内容是：()
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")   # t3的类型是：, 内容是：()
# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")            # t4的类型是：, t4的内容是：('hello',)
# 如果不加逗号，则变成字符串类型
t4_0 = ("hello")
print(f"t5的类型是：{type(t5)}, t5的内容是：{t5}")    		# t5的类型是：, t5的内容是：hello

5.3.3 下标索引

# 元组的嵌套
t = ( (1, 2, 3), [4, 5, 6] )
print(f"t的类型是：{type(t)}, 内容是：{t}")
# 下标索引去取出内容
num = t[-1][2]
print(f"从嵌套元组中取出的数据是：{num}")

5.3.4 常用操作

因为元组不可修改，所以列表的很多增删改的方法都不能使用。

5.3.4.1 元组的查询功能

语法：元组.index(元素)
功能：查找指定元素在元组的下标，如果找不到，报错ValueError。

5.3.4.2 元组的统计功能

语法：元组.count(元素)
功能：统计元组内某元素的数量。
语法：len(元组)
功能：统计元组中全部的元素数量。

t = ("element1", "element2", "element2", "element2", "element3")
# 查找指定元素在元组的下标，如果找不到，报错ValueError
index = t.index("element2")
print(f"在元组t中查找element2，的下标是：{index}")     # 1
# 统计元组内某元素的数量
num = t.count("element2")
print(f"在元组t中统计element2的数量有：{num}个")       # 3
# 统计元组中全部的元素数量
num = len(t)
print(f"t元组中的元素有：{num}个")                   # 5
# error：元组不支持元素的重新分配
# t8[0] = "modify"
# 可以修改元组内的list的内容（修改元素、增加、删除、反转等），但不可以替换list为其它list或其它类型
t = (1, 2, ["element1", "element2"])
t[2][0] = "元素1"
t[2][1] = "元素2"
print(f"t的内容是：{t}")     # t的内容是：(1, 2, ['元素1', '元素2'])

5.3.5 遍历

5.3.5.1 while

t = ("element1", "element2", "element2", "element2", "element3")
# 元组的遍历：while
index = 0
while index < len(t):
    print(f"元组的元素有：{t[index]}")
    index += 1

5.3.5.2 for

t = ("element1", "element2", "element2", "element2", "element3")
# 元组的遍历：for
for element in t:
    print(f"元组的元素有：{element}")

5.4 字符串

5.4.1 定义

字符串是字符的容器，每一个字符就是字符串的一个元素。例如：“itheima”。

5.4.2 特点

元组可以认为是只读的列表。元组一旦定义完成，就不可修改。
①长度任意（取决于内存大小）；
②只能存储字符串；
③数据是有序存储的（有下标索引）；
④允许重复字符串存在；
⑤不可以增删改操作；
⑥支持while循环和for循环遍历。

5.4.3 下标索引

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。

# 通过下标索引取值
my_str = "hello and hi"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-10]
print(f"从字符串{my_str}取下标为2的元素，值是：{value},取下标为-10的元素，值是：{value2}")    # l l
# TypeError，字符串是不可修改的数据容器
# my_str[2] = "H"

字符串之间比较大小：按位比较，也就是按顺序一位位进行对比，只要其中一位大，整体就大，后面就无需比较了。

下一位有数据的比下一位没有数据的字符串整体大。

# abcabc 比较 abdeee
print(f"abcabc大于abdeee，结果：{'abd' > 'abc'}")  # True
# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")             # True
# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")             # True
# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")   # True，因为key2、key1是字符串，按位比较，最后得到2>1

5.4.4 常用操作

5.4.4.1 字符串的查询功能

语法：字符串.index(字符串)
功能：查找特定字符串的下标索引值。

5.4.4.2 字符串的替换功能

语法：字符串.replace(字符串1, 字符串2)
功能：将匹配到的字符串1全部替换为字符串2。
注意：不是修改字符串本身，而是得到了一个新字符串。

5.4.4.3 字符串的分割功能

语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。
注意：字符串本身不变，而是得到了一个列表对象。

5.4.4.4 字符串的规整功能

语法：字符串.strip()
功能：去除字符串前后所有空格以及回车符。
注意：注意，加入传入的参数是“12”，其实就是把12分为两个小字符串，只要满足任意1个，都会移除。相当于去除字符串"1"和字符串"2"。

5.4.4.5 字符串的统计功能

语法：字符串.count(字符串)
功能：统计字符串内某元素的数量。
语法：len(字符串)
功能：统计字符串中全部的元素数量。

my_str = "hello and helloworld"
# 查找特定字符串的下标索引值
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")     # 6
# 将匹配到的字符串1全部替换为字符串2
new_my_str = my_str.replace("hello", "程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")      # 将字符串hello and helloworld，进行替换后得到：程序 and 程序world
# 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")   # 将字符串hello and helloworld进行split切分后得到：['hello', 'and', 'helloworld'], 类型是：
# 去除字符串前后所有空格以及回车符
my_str = "  hello and helloworld  "
new_my_str = my_str.strip()
print(f"字符串{my_str}被strip后，结果：{new_my_str}")    # 字符串  hello and helloworld  被strip后，结果：hello and helloworld
# 去除字符串前后指定字符串
my_str = "12hello and helloworld21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")      # 字符串12hello and helloworld21被strip('12')后，结果：hello and helloworld
# 统计字符串中某字符串的出现次数
my_str = "hello and helloworld 编程"
count = my_str.count("he")
print(f"字符串{my_str}中it出现的次数是：{count}")      # 2
# 统计字符串的长度
num = len(my_str)
# 所有单个中英文字符都算1个字符
print(f"字符串{my_str}的长度是：{num}")              # 23

5.4.5 遍历

5.4.5.1 while

str = ("element1", "element2", "element2", "element2", "element3")
# 字符串的遍历：while
index = 0
while index < len(str):
    print(f"字符串的元素有：{str[index]}")
    index += 1

5.4.5.2 for

str = ("element1", "element2", "element2", "element2", "element3")
# 字符串的遍历：for
for element in str:
    print(f"字符串的元素有：{element}")

5.5 序列

5.5.1 定义

序列：内容连续、有序、可重复、可使用下标索引的一类数据容器，例如列表、元组、字符串。
非序列：内容连续、无序、不可重复、不可使用下标索引的一类数据容器，例如集合、字典。

5.5.2 下标索引

和其它容器如：列表、元组、字符串一样，序列也可以通过下标进行访问。

5.5.3 常用操作-切片

定义：从一个序列中，取出一个子序列。列表、元组、字符串、序列均支持进行切片操作。
语法：序列[起始下标:结束下标:步长]
功能：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：①起始下标表示从何处开始，可以留空，留空视作从头开始；②结束下标（不含本身）表示何处结束，可以留空，留空视作截取到结尾；③步长表示依次取元素的间隔。步长N表示，每次跳过N-1个元素取，步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）；不写步长默认是1。
注意：切片不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串），是因为元组和字符串是不支持修改的。

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

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

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

my_list = [0, 1, 2, 3, 4, 5, 6]     # 对列表进行切片，从3开始，到1结束，步长-1
result4 = my_list[3:1:-1][::-1]		# 可以组合写，因为切片是得到新的数据容器，[::-1]表示反转
print(f"结果4：{result4}")           # [2, 3]

5.6 集合

5.6.1 定义

以 { } 作为标识，容器内每一个元素之间用英文逗号隔开。
语法：变量名 = {元素1,元素2...元素n}
定义空列表语法：变量名 = set()
注意：变量名 = { }中，变量名是字典类型。

my_set = {"element1", "element2", "element3", "element1", "element2", "element3"}   # 定义集合
my_set_empty = set()                                                          # 定义空集合
my_dict_empty = {}
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")                        # {'element3', 'element1', 'element2'}，每一次输出顺序不一样
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")      # my_set_empty的内容是：set(), 类型是：
print(f"my_dict_empty的内容是：{my_dict_empty}, 类型是：{type(my_dict_empty)}")   # my_dict_empty的内容是：{}, 类型是：
my_set = {"C", "Java", "PHP", "C", "Java", 1 ,1.5}
print(f"my_set的内容是：{my_set})	# 可以混转简单数据类型
my_set = {"C", "Java", "PHP", "C", "Java", [1, 2, 3]}
# print(f"my_set的内容是：{my_set})	# TypeError: unhashable type: 'list'，不能混装数据容器

5.6.2 特点

①可以容纳多个元素；
②可以混转简单数据类型，不能混装数据容器；
③数据是无序存储的（不支持下标索引）；
④不允许重复数据存在，会自动去重；
⑤可以增删改操作。
⑥只支持for循环遍历。

5.6.3 下标索引

因为集合是无序的，所以集合不支持下标索引访问，也不支持查询，并且也不是序列。

5.6.4 常用操作

5.6.4.1 集合的添加功能

语法：集合.add(元素)
功能：将指定的元素，添加到集合内。
结果：如果添加新元素，集合本身被修改，否则集合还是本身不变。

5.6.4.2 集合的移除功能

语法：集合.remove(元素)
功能：将指定的元素，从集合内移除。
结果：集合本身被修改，移除了元素。

5.6.4.3 集合的删除功能

语法：集合.pop()
功能：从集合中随机取出一个元素。
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除。

5.6.4.4 集合的清空功能

语法：集合.clear()
功能：清空集合。
结果：集合本身被修改，变成空集合。

5.6.4.5 集合的修改功能

5.6.4.5.1 取出2个集合的差集

语法：集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）。
结果：得到一个新集合，集合1和集合2不变。

5.6.4.5.2 消除2个集合的差集

语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
结果：集合1被修改，集合2不变。

5.6.4.5.3 合并2个集合

语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合。
结果：得到新集合，集合1和集合2不变。

5.6.4.6 集合的统计功能

语法：len(集合)
功能：统计集合内有多少元素。

my_set = {"C", "Java", "PHP", "C", "Java"}
my_set.add("Python")                         # 添加新元素
my_set.add("Java")                           # 添加重复元素
print(f"my_set添加元素后结果是：{my_set}")       # {'C', 'PHP', 'Java', 'Python'}

my_set.remove("PHP")                         # 移除元素
print(f"my_set移除PHP后，结果是：{my_set}")     # {'C', 'Java', 'Python'}

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

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

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

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

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

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

5.6.5 遍历

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

my_set = {"C", "Java", "PHP", "C", "Java"}
# 字符串的遍历：for
for element in str:
    print(f"字符串的元素有：{element}")

5.7 字典

5.7.1 定义

以 { } 作为标识，存储的元素是一个个的键值对。
每一个键值对包含Key和Value（用冒号分隔），键值对之间使用逗号分隔，Key和Value可以是任意类型的数据（key不可为字典），Key不可重复，重复会对原有数据覆盖。
语法：变量名 = {key1:value1,key2:value2...key3:value3}
定义空字典语法1：变量名 = { }
定义空字典语法2：dict()

my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}    # 定义字典
my_dict2 = {}       # 定义空字典
my_dict3 = dict()   # 定义空字典
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")   # {'王力鸿': 99, '周杰轮': 88, '林俊节': 77}, 类型：
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")   # 字典2的内容是：{}, 类型：
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")   # 字典3的内容是：{}, 类型：
stu_score_dict = {  # 定义嵌套字典
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")   # {'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}
score = stu_score_dict["周杰轮"]["语文"]     # 从嵌套字典中获取数据
print(f"周杰轮的语文分数是：{score}")          # 88

5.7.2 特点

①可以容纳多个元素，且每个元素都是键值对；
②可以混转不同数据类型（Key不可为字典）；
③数据不支持下标索引；
④可以通过Key获取到Value，Key不可重复（重复会覆盖）；
⑤可以增删改操作。
⑥只支持for循环遍历。

5.7.3 下标索引

字典同集合一样，不可以使用下标索引。但是字典可以通过Key值来取得对应的Value。
语法：字典[key]

my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]         # 从字典中基于Key获取Value
print(f"王力鸿的考试分数是：{score}")		# 99

5.7.4 常用操作

5.7.4.1 字典的增加功能

语法：字典[Key] = Value
功能：新增元素Key:Value，字典本身被修改。

5.7.4.2 字典的更新功能

语法：字典[Key] = Value
功能：更新元素Key:Value，字典本身被修改。
区别：更字典的增加语法一样，区别在于字典的增加是key原来不存在，字典的更新是key已存在。

5.7.4.3 字典的删除功能

语法：字典.pop(Key)
功能：获得指定Key的Value，同时字典被修改，指定Key的数据被删除。
语法：字典.clear()
功能：元素被清空，字典被修改。

5.7.4.4 字典的获取功能

语法：字典.keys()
功能：得到字典中的全部Key。

5.7.4.5 字典的统计功能

语法：len(字典)
功能：计算字典内的全部元素（键值对）数量。

my_dict = {"林俊节": 88, "张学油": 77}
my_dict["周杰轮"] = 99                       # 新增元素
print(f"字典经过新增元素后，结果：{my_dict}")    # {'林俊节': 88, '张学油': 77, '周杰轮': 99}

my_dict["周杰轮"] = 33                       # 更新元素
print(f"字典经过更新后，结果：{my_dict}")       # {'林俊节': 88, '张学油': 77, '周杰轮': 33}

score = my_dict.pop("周杰轮")                                              # 删除元素
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")      # {'林俊节': 88, '张学油': 77}

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

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()               # 获取全部的key
print(f"字典的全部keys是：{keys}")     # dict_keys(['周杰轮', '林俊节', '张学油'])

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

5.7.5 遍历

字典不支持下标索引，所以同样不可以用while循环遍历。但是有两种for循环的遍历方式。
①通过获取到全部的key来完成遍历。
②直接对字典进行for循环，每一次循环都是直接得到key。

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()               # 获取全部的key
print(f"字典的全部keys是：{keys}")     # dict_keys(['周杰轮', '林俊节', '张学油'])

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


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

5.8 数据容器总结

5.8.1 数据容器的区别

5.8.1 数据容器的通用操作

5.8.2.1 len

都可以通过len来求数据容器内元素的个数。

5.8.2.2 遍历

都可以通过for循环来遍历数据容器内元素。

5.8.2.3 max

语法：max(数据容器)
功能：统计容器的最大元素。

5.8.2.4 min

语法：min(数据容器)
功能：统计容器的最小元素。

5.8.2.5 容器的转换功能

语法：list(容器)
功能：将给定容器转换为列表。
注意：字典转列表，只对取key值，value的值被抛弃。
语法：tuple(容器)
功能：将给定容器转换为元组。
注意：字典转元组，只对取key值，value的值被抛弃。
语法：str(容器)
功能：将给定容器转换为字符串。输出的时候隐藏双引号，实际内容其实带双引号的。
注意：字典转字符串，key值和value值都会保留。
语法：set(容器)
功能：将给定容器转换为集合。
注意：①字符串转集合，数据也变成无序。
②如果有重复的字符，也会被去重。
③字典转集合，只取key值，value的值被抛弃，且顺序乱掉。
④其他容器转字典是无法转换的，因为要求元素是键值对。

5.8.2.5 容器的排序功能

语法：sorted(容器, [reverse=True])
功能：将给定容器进行排序，结果变为列表对象。
说明：reverse表示反转，默认为False（升序）。如果想容器的排序进行反转（降序），传递一个True就可以。
注意：对字典进行排序，只取key值，value的值被抛弃。

my_list = [1, 2, 3, 3]
my_tuple = (1, 2, 3, 3)
my_str = "abcc"
my_set = {1, 2, 3, 3}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key3": 3}
# max求容器最大元素
print(f"列表 最大的元素是：{max(my_list)}")      # 3
print(f"元组 最大的元素是：{max(my_tuple)}")     # 3
print(f"字符串最大的元素是：{max(my_str)}")       # c
print(f"集合 最大的元素是：{max(my_set)}")       # 3
print(f"字典 最大的元素是：{max(my_dict)}")      # key3
# min求容器最小元素
print(f"列表 最小的元素是：{min(my_list)}")      # 1
print(f"元组 最小的元素是：{min(my_tuple)}")     # 1
print(f"字符串最小的元素是：{min(my_str)}")       # a，通过ASCII码值比较字符的大小
print(f"集合 最小的元素是：{min(my_set)}")       # 1
print(f"字典 最小的元素是：{min(my_dict)}")      # key1
# 类型转换: 容器转列表，会产生新的列表，不更改原来的字面量
print(f"列表转列表的结果是：{list(my_list)}")     # [1, 2, 3, 3]
print(f"元组转列表的结果是：{list(my_tuple)}")    # [1, 2, 3, 3]
print(f"字符串转列表结果是：{list(my_str)}")      # ['a', 'b', 'c', 'c']
print(f"集合转列表的结果是：{list(my_set)}")      # [1, 2, 3]
print(f"字典转列表的结果是：{list(my_dict)}")     # ['key1', 'key2', 'key3']
# 类型转换: 容器转元组，会产生新的元组，不更改原来的字面量
print(f"列表转元组的结果是：{tuple(my_list)}")    # (1, 2, 3, 3)
print(f"元组转元组的结果是：{tuple(my_tuple)}")   # (1, 2, 3, 3)
print(f"字符串转元组结果是：{tuple(my_str)}")     # ('a', 'b', 'c', 'c')
print(f"集合转元组的结果是：{tuple(my_set)}")     # (1, 2, 3, 4, 5)
print(f"字典转元组的结果是：{tuple(my_dict)}")    # ('key1', 'key2', 'key3')
# 类型转换: 容器转字符串，会产生新的字符串，不更改原来的字面量
print(f"列表转字符串的结果是：{str(my_list)}")     # [1, 2, 3, 3]，实际是"[1, 2, 3, 3]"
print(f"元组转字符串的结果是：{str(my_tuple)}")    # (1, 2, 3, 3)，实际是"(1, 2, 3, 3)"
print(f"字符串转字符串结果是：{str(my_str)}")      # abcc，实际是"abcc"
print(f"集合转字符串的结果是：{str(my_set)}")      # {1, 2, 3}，实际是"{1, 2, 3}"
print(f"字典转字符串的结果是：{str(my_dict)}")     # {'key1': 1, 'key2': 2, 'key3': 3}，实际是"{'key1': 1, 'key2': 2, 'key3': 3}"
# 类型转换: 容器转集合，会产生新的集合，不更改原来的字面量
print(f"列表转集合的结果是：{set(my_list)}")      # {1, 2, 3}
print(f"元组转集合的结果是：{set(my_tuple)}")     # {1, 2, 3}
print(f"字符串转集合结果是：{set(my_str)}")       # {'b', 'c', 'a'}
print(f"集合转集合的结果是：{set(my_set)}")       # {1, 2, 3}
print(f"字典转集合的结果是：{set(my_dict)}")      # {'key3', 'key1', 'key2'}
# dict()    # error，其他容器转字典是无法转换的，因为要求元素是键值对
# 解包运算符 * 将元组转换为列表，适用于于 Python 3.5 及更高版本中，会产生新的列表，不更改原来的元组
mix_tuple = (100, 100.1, 'str', (100, 'tuple'), [100.1, 'list'])
unpack_list = [*mix_tuple]
print(f"利用解包运算符将元组转化为列表：{unpack_list}")     # [100, 100.1, 'str', (100, 'tuple'), [100.1, 'list']]
# 使用列表推导方法将元组及其第一层嵌套的元组转换为列表，会产生新的列表，不更改原来的元组
tuple_nest = (((5,6),(8,9)),((9,5),(4,2)))
list_for = [list(row) for row in tuple_nest]
print(list_for)
# 使用 map() 将元组及其第一层嵌套的元组转换为列表，会产生新的列表，不更改原来的元组
# map(容器关键字,需要转化的容器)
list_map = list(map(list,tuple_nest))
print(list_map)
# 进行容器的排序
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
print(f"列表对象的排序结果：{sorted(my_list)}")   # [1, 2, 3, 4, 5]
print(f"元组对象的排序结果：{sorted(my_tuple)}")  # [1, 2, 3, 4, 5]
print(f"字符串对象的排序结果：{sorted(my_str)}")   # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(f"集合对象的排序结果：{sorted(my_set)}")    # [1, 2, 3, 4, 5]
print(f"字典对象的排序结果：{sorted(my_dict)}")   # ['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)}")

码字不易，如果大家觉得有用，请高抬贵手给一个赞让文章上推荐让更多的人看到吧，也可以评论提出意见让后面的文章内容越来越生动丰富。