【Python】数据容器：列表，元组，字符串，集合字典及通用操作

文章目录

• 一.序列
• • 1.1list列表
  • • 定义
    • 常用操作
    • 列表的遍历
  • 1.2tuple元组
  • • 定义
    • 常见操作
    • 元组的遍历
  • 1.3str字符串
  • • 定义
    • 常见操作
    • 字符串的遍历
  • 1.4序列常用操作------切片
• 二.set集合
• • 定义
  • 常见操作
  • 集合的遍历
• 三.dict字典
• • 定义
  • 常用操作
  • 字典的嵌套
• *数据容器对比总结
• 四.数据容器的通用操作
• • 4.1通用统计功能
  • 4.2通用转换功能
  • 4.3通用排序功能

我们首先来思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。如何做呢？

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

Python中的数据容器：

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

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

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

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

一.序列

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

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

1.1list列表

定义

列表内的每一个数据，称之为元素

以[ ] 作为标识

列表内每一个元素之间用, 逗号隔开

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

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

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

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

演示代码：

# 字符串列表
name_list = ['green','yello','blue']
print(name_list)
print(type(name_list))

# 各种类型列表
name_list = ['green','666','blue']
print(name_list)
print(type(name_list))

# 嵌套列表
name_list = [['green'],['666'],['blue']]
print(name_list)
print(type(name_list))

'''运行结果：
['green', 'yello', 'blue']
<class 'list'>
['green', '666', 'blue']
<class 'list'>
[['green'], ['666'], ['blue']]
<class 'list'>'''

列表的下标索引

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

我们只需要按照下标索引，即可取得对应位置的元素。

②或者，可以反向索引，如图，从后向前，下标索引为：-1、-2、-3，依次递减。

③如果列表是嵌套的列表，同样支持下标索引

演示代码：

# 正向索引
name_list = ['green','yello','blue']
print(name_list[0])
print(name_list[1])
print(name_list[2])

# 反向索引
name_list = ['green','yello','blue']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

# 嵌套索引
name_list = [[1,2,3],[4,5],[6,7,8]]
print(name_list[0][0])
print(name_list[-2][-1])
print(name_list[-3][2])

'''运行结果：
green
yello
blue
blue
yello
green
1
5
3
'''

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

常用操作

①查找

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

【语法】：列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

如果被查找的元素不存在，会报错

②修改

【功能】：修改特定位置（索引）的元素值

【语法】：列表[下标]=值

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

③插入

【功能】：在指定的下标位置，插入指定的元素

【语法】：列表.insert(下标,元素)

④追加

【功能】：将指定元素，追加到列表的尾部

【语法】：列表.append(元素)

追加一批元素->列表.extend(其他数据容器)

⑤索引删除

【语法1】：del 列表[下标]

【语法1】：列表.pop(下标)，同时可以把删除的元素作为返回值去得到

⑥指定内容删除

【语法】：列表.remove(元素)

从前到后搜索，只能删掉一个指定内容的元素

⑦清空列表

【语法】：列表.clear()

⑧统计

【语法】：列表.count(元素)

【功能】：统计某元素在列表中数量

【语法】：len(列表)

【功能】：统计列表内有多少元素

代码示例

name_list = ['green','yello','blue']
# 查找
index = name_list.index("yello")
print(f"yello在列表中的下标索引值是：{index}")
# 修改
name_list[0] = "修改"
print(f"列表被修改元素值后，输出结果是：{name_list}")
# 插入
name_list.insert(1,'插入')
print(f"列表插入元素后，结果是：{name_list}")
# 追加
name_list.append('追加')
print(f"列表追加元素后，结果是：{name_list}")
# 追加一批元素
name_list.extend([1,1,3])
print(f"列表追加一个新的列表后，结果是：{name_list}")
# 删除
del name_list[0]
print(f"列表删除元素后，结果是：{name_list}")
element = name_list.pop(0)
print(f"通过pop取出元素后，结果是：{name_list}，取出的元素是{element}")
# 指定内容删除
name_list.remove('追加')
print(f"列表删除指定内容元素后，结果是：{name_list}")
# 统计
count = name_list.count(1)
print(f"列表中1的数量是：{count}")
num = len(name_list)
print(f"列表中的元素数量是：{num}")
# 清空
name_list.clear()
print(f"列表被清空了，结果是：{name_list}")

'''运行结果：
yello在列表中的下标索引值是：1
列表被修改元素值后，输出结果是：['修改', 'yello', 'blue']
列表插入元素后，结果是：['修改', '插入', 'yello', 'blue']
列表追加元素后，结果是：['修改', '插入', 'yello', 'blue', '追加']
列表追加一个新的列表后，结果是：['修改', '插入', 'yello', 'blue', '追加', 1, 1, 3]
列表删除元素后，结果是：['插入', 'yello', 'blue', '追加', 1, 1, 3]
通过pop取出元素后，结果是：['yello', 'blue', '追加', 1, 1, 3]，取出的元素是插入
列表删除指定内容元素后，结果是：['yello', 'blue', 1, 1, 3]
列表中1的数量是：2
列表中的元素数量是：5
列表被清空了，结果是：[]

Process finished with exit code 0
'''

总结列表的特点：

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

列表的遍历

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

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

• while循环

# 定义一个变量来标记列表的下标
index = 0     # 初始值为0
while index < len(列表):   # 循环条件为：下标值<列表的元素数量
    元素 = 列表[index]
    对元素进行处理
    index += 1

• for循环

对比while，for循环更加适合对列表等数据容器进行遍历。

for 临时变量 in 数据容器 :
    对临时变量进行处理

for循环和while对比

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

1. 在循环控制上:

   ·white循环可以自定循环条件，并自行控制

   ·for循环不可以自定循环条件，只可以一个个从容器内取出数据

2. 在无限循环上:

   ·while福环可以通过条件控制做到无限循环

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

3. 在使用场景上:

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

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

【代码示例】

# 使用while循环遍历列表
def list_while_func():
    my_list = ["blue", "yello", "green"]
    # 定义一个变量来标记列表的下标
    index = 0  # 初始值为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")
        index += 1
list_while_func()

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

'''运行结果：
列表的元素：blue
列表的元素：yello
列表的元素：green
列表元素有：1
列表元素有：2
列表元素有：3
列表元素有：4
列表元素有：5'''

---

列表是可以修改的，如果想要传递的信息不被纂改，那么元组来啦~

1.2tuple元组

定义

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

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

#定义元组字面量
(元素，元素，......，元素)

#定义元组数=变量
变量名称 = (元素，元素，...... ，元素)

#定义空元组
变量名称 = ()          #方式一
变量名称 = tuple()     #方式二

注：

1、元组只有一个数据时，这个数据后面要添加逗号，否则不是元组类型！

2、元组也支持嵌套

代码示例：

t1 = (1,"Hello",True)
t2 = ()
t3 = tuple ()
t4 = (1,)
t5 = ((4,5,6),(8,9))
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")
print(f"t4的类型是：{type(t4)},内容是：{t4}")
print(f"t5的类型是：{type(t5)},内容是：{t5}")

'''运行结果：
t1的类型是：<class 'tuple'>,内容是：(1, 'Hello', True)
t2的类型是：<class 'tuple'>,内容是：()
t3的类型是：<class 'tuple'>,内容是：()
t4的类型是：<class 'tuple'>,内容是：(1,)
t5的类型是：<class 'tuple'>,内容是：((4, 5, 6), (8, 9))'''

元组的下标索引

同列表，示例：

t5 = ((4,5,6),(8,9))
num = t5[1][0]
'''运行结果：
8'''

常见操作

元组由于不可修改的特性，所以其操作方法非常少。

元组的三种方法和列表相对应的这三种方法操作一致。

元组的遍历

元组同样支持while循环和for循环的遍历操作

用法和列表遍历一致

总结元组的特点

• 可以容纳多个数据

• 可以容纳不同类型的数据（混装）

• 数据是有序存储的（下标索引）

• 允许重复数据存在

• 不可以修改 （增加或删除元素等），但如果元组中嵌套的有列表，那么列表中的元素可以修改（列表list的本质没有改变，所以不违背元组不可以修改的原则）

• 支持for循环

1.3str字符串

定义

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

字符串的下标索引

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

• 从前向后，下标从 0 开始

• 从后向前，下标从 -1 开始

【代码示例】

my_str = "abcdefg"
value1 = my_str[2]
value2 = my_str[-3]
print(f"从字符串中取下标为2的元素值是{value1},下标为-3的元素值是{value2}")

'''运行结果：
从字符串中取下标为2的元素值是c,下标为-3的元素值是e'''

常见操作

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

①字符串的替换

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

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

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

②字符串的分割

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

【语法】：字符串.split(分隔符字符串)

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

③字符串的规整操作

【功能】：去前后空格

【语法】：```字符串.strip()``

【功能】：去前后指定字符串

【语法】：```字符串.strip(字符串)``

注意：传入的是"12"，其实就是："1"和"2"都会移除，是按照单个字符

④查找

【功能】：查找给定字符的第一个匹配项的下标

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

代码示例

# 查找
str = "mountain and sea"
value = str.index("and")
print(f"在字符串{str}中查找"and"，其起始下标是{value}")

# 替换
str = "itmountain and itsea"
new_str = str.replace("it","程序")
print(f"将字符串 {str}，进行替换得到 {new_str}")

# 分割
my_str = "hello python itCSDN itlove"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# 规整操作
my_str = "  itCSDN and itlove  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")
my_str = "12itCSDN and itlove21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计
my_str = "itCSDN and itlove"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
my_str = "itCSDN and itlove"
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

'''运行结果：
在字符串mountain and sea中查找"and"，其起始下标是9
将字符串 itmountain and itsea，进行替换得到 程序mountain and 程序sea
将字符串hello python itCSDN itlove进行split切分后得到：['hello', 'python', 'itCSDN', 'itlove'], 类型是：<class 'list'>
字符串  itCSDN and itlove  被strip后，结果：itCSDN and itlove
字符串12itCSDN and itlove21被strip('12')后，结果：itCSDN and itlove
字符串itCSDN and itlove中it出现的次数是：2
字符串itCSDN and itlove的长度是：17
'''

字符串的遍历

同列表，元组一样

总结元组的特点

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

• 只可以存储字符串

• 长度任意（取决于内存大小）

• 支持下标索引

• 允许重复字符串存在

• 不可以修改 （增加或删除元素等）

• 支持for循环

1.4序列常用操作------切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始

• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

• 步长表示，依次取元素的间隔，默认为1：步长 1 表示，一个个取元素；步长 2 表示，每次跳过1个元素取；步长 N表示，每次跳过N-1 个元素取

• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意. 此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

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

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

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

'''运行结果：
结果1：[1, 2, 3]
结果6：[3, 2]
结果2：(0, 1, 2, 3, 4, 5, 6)
结果5：(6, 4, 2, 0)
结果3：0246
结果4：76543210
'''

---

总结：

• 列表可修改，支持重复元素且有序
• 元组，字符串不可修改，支持重复元素且有序

序列这三种数据容器基本可以满足大多数使用场景，但是它们存在局限：都支持重复元素。如果场景需要对内容做去重处理，就不方便了，那么集合来啦~

二.set集合

定义

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

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

# 定义集合字面量
{元素，元素，.... ，元素}
# 定义集合变量
变量名称 = {元素，元素，.... ，元素}
# 定义空集合
变量名称 = set()

结合集合特点进行代码演示：

my_set_empty = set()        # 定义空集合
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")
my_set = {"CSDN程序员社区", "CSDN灌水乐园", "itCSDN", "CSDN灌水乐园", "CSDN程序员社区", "itCSDN"}
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")

'''运行结果：
my_set_empty的内容是：set(), 类型是：<class 'set'>
my_set的内容是：{'itCSDN', 'CSDN灌水乐园', 'CSDN程序员社区'}, 类型是：<class 'set'>'''

常见操作

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

但是结合和列表一样，是允许修改的，所以我们来看看集合的修改方法------

①添加新元素

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

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

②移除元素

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

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

③随机取出元素

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

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

④清空集合

【语法】：集合.clear()，清空集合

结果：集合本身被清空

⑤取出两个集合的差集

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

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

⑥消除差集

【语法】：集合1.difference_update(集合2)，对比集合1和集合2相同的元素

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

⑦两个集合合并

【语法】：集合1.union(集合2)，将集合1和集合2组合成新集合

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

【代码示例】

# 添加新元素
my_set = {"blue", "green", "pink"}
my_set.add("purple")
my_set.add("pink")
print(f"my_set添加元素后结果是：{my_set}")

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

# 随机取出元素
my_set.pop()
print(f"my_set随机取出元素后，结果是：{my_set}")

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

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

# 消除差集
set1 = {1,2,3}
set2 = {1,4,5,6}
set3 = set1.difference_update(set2)
print(f"消除差集后，原有set1的内容：{set1}")
print(f"消除差集后，原有set2的内容：{set2}")
print(f"消除差集后的集合3是：{set3}")

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

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

'''运行结果：
my_set添加元素后结果是：{'pink', 'purple', 'green', 'blue'}
my_set移除green后，结果是：{'pink', 'purple', 'blue'}
my_set随机取出元素后，结果是：{'purple', 'blue'}
my_set清空集合后，结果是：set()
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 4, 5, 6}
消除差集后，原有set1的内容：{2, 3}
消除差集后，原有set2的内容：{1, 4, 5, 6}
消除差集后的集合3是：None
合并后，原有set1的内容：{1, 2, 3}
合并后，原有set2的内容：{1, 4, 5, 6}
合并后的集合3是：{1, 2, 3, 4, 5, 6}
集合1内的元素数量有：3个
集合2内的元素数量有：3个'''

集合的遍历

因为集合是无序的，不支持下标索引，所以不可以使用while循环遍历，用for循环遍历

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

总结集合的特点

• 可以容纳多个数据

• 可以容纳不同类型的数据（混装）

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

• 不允许重复数据存在

• 可以修改 （增加或删除元素等）

• 支持for循环

三.dict字典

定义

通过 key 找出对应的 value

qa4tRBmD-1736684061659)

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对：key，：，value三者结合被称为键值对，如下语法：

# 定义字典字面量
{key : value , key value : value ,....,key : value}
# 定义字典字面量
my_dict = {key : value , key :value , ....,key :value}
# 定义空字典
my_dict = {}     # 空字典定义方式1
my_dict = dict() # 空字典定义方式2

• 使用 {} 存储原始，每一个元素是一个键值对

• 每一个键值对包含 Key 和 Value （用冒号分隔）

• 键值对之间使用逗号分隔

• Key 和 Value 可以是任意类型的数据 （ key 不可为字典）

• Key 不可重复，重复会对原有数据覆盖

•字典不可用下标索引，而是通过Key检索Value

【代码示例】

# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")

'''运行结果：
字典1的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77}, 类型：<class 'dict'>
字典2的内容是：{}, 类型：<class 'dict'>
字典3的内容是：{}, 类型：<class 'dict'>'''

常用操作

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

【代码示例】

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

'''运行结果：
王力鸿的考试分数是：99
周杰轮的考试分数是：88'''

①新增元素

【语法】：字典[Key] = Value

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

②更新元素

【语法】：字典[Key] = Value

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

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

③删除元素

【语法】：字典.pop(Key)

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

④清空字典

【语法】：字典.clear()

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

⑤获取全部Key

【语法】：字典.Keys()

结果：得到字典中全部的Key

⑥计算字典中元素数量

【语法】：len.(字典)

---

【代码示例】

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

# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
#更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")

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

# 清空字典
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取字典中全部的Key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 计算字典中的元素数量
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

'''运行结果：
王力鸿的考试分数是：99
周杰轮的考试分数是：88
字典经过新增元素后，结果：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77, '张信哲': 66}
字典经过更新后，结果：{'王力鸿': 99, '周杰轮': 33, '林俊节': 77, '张信哲': 66}
字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77}, 周杰轮的考试分数是：99
字典被清空了，内容是：{}
字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])
字典的key是:周杰轮
字典的value是：99
字典的key是:林俊节
字典的value是：88
字典的key是:张学油
字典的value是：77
字典中的元素数量有：3个
'''

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

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

方法①：通过获取到全部的key来遍历完成

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

'''运行结果：
字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])
字典的key是:周杰轮
字典的value是：99
字典的key是:林俊节
字典的value是：88
字典的key是:张学油
字典的value是：77
'''

方法②：直接对字典进行for循环，每一次循环都是直接得到key

my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
for key in my_dict:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")
    
'''运行结果：
字典的key是:周杰轮
字典的value是：99
字典的key是:林俊节
字典的value是：88
字典的key是:张学油
字典的value是：77
'''

总结字典的特点

• 可以容纳多个数据

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

• 每一份数据是 KeyValue 键值对

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

• 不支持下标索引

• 可以修改 （增加或删除更新元素等）

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

*数据容器对比总结

• 列表使用： []

• 元组使用： ()

• 字符串使用：""

• 集合使用： {}

•字典使用：{}和键值对

遍历方式不同：

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

四.数据容器的通用操作

4.1通用统计功能

【代码示例】

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}

# 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)}")

# max最大元素
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)}")

# min最小元素
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)}")

'''运行结果：
列表 元素个数有：5
元组 元素个数有：5
字符串元素个数有：7
集合 元素个数有：5
字典 元素个数有：5
列表 最大的元素是：5
元组 最大的元素是：5
字符串最大的元素是：g
集合 最大的元素是：5
字典 最大的元素是：key5
列表 最小的元素是：1
元组 最小的元素是：1
字符串最小的元素是：a
集合 最小的元素是：1
字典 最小的元素是：key1'''

4.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}

# 类型转换: 容器转列表
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")

# 类型转换: 容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")

# 类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")

# 类型转换: 容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合结果是：{set(my_str)}")
print(f"字典转集合的结果是：{set(my_dict)}")

'''运行结果：
元组转列表的结果是：[1, 2, 3, 4, 5]
字符串转列表结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合转列表的结果是：[1, 2, 3, 4, 5]
字典转列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']
列表转元组的结果是：(1, 2, 3, 4, 5)
字符串转元组结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
集合转元组的结果是：(1, 2, 3, 4, 5)
字典转元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')
列表转字符串的结果是：[1, 2, 3, 4, 5]
元组转字符串的结果是：(1, 2, 3, 4, 5)
集合转字符串的结果是：{1, 2, 3, 4, 5}
字典转字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
列表转集合的结果是：{1, 2, 3, 4, 5}
元组转集合的结果是：{1, 2, 3, 4, 5}
字符串转集合结果是：{'c', 'b', 'd', 'a', 'f', 'e', 'g'}
字典转集合的结果是：{'key1', 'key5', 'key2', 'key3', 'key4'}
'''

4.3通用排序功能

【语法】：sorted(容器，[reverse = True])，将给定的容器进行排序

# 进行容器的排序
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)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")

# 逆序排序
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)}")

'''运行结果：
列表对象的排序结果：[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, 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']
'''