【Python】一文带你掌握数据容器之集合，字典

目录：

一、集合

思考：我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景为何又需要学习新的集合类型呢?

通过特性来分析:
（1）列表可修改、支持重复元素且有序
（2）元组、字符串不可修改、支持重复元素且有序

大家有没有看出一些局限?

局限就在于：它们都支持重复元素

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

而集合，最主要的特点就是:不支持元组的重复(自带去重功能)、并且内容无序

---

1.集合的定义

基本语法:

1. # 定义集合字面量
2. {元素,元素,......,元素}
4. # 定义集合变量
5. 变量名称 = {元素,元素,......,元素}
7. # 定义空集合
8. 变量名称 = set()

 和列表、元组、字符串等定义基本相同:

列表使用[  ]

元组使用( )

字符串使用"  "

集合使用{  }

---

 2.集合的常用操作

首先，因为集合是无序的，所以集合不支持:下标索引访问但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法

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

(1)添加新元素

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

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

1. my_set = {"Hello", "World"}
2. my_set.add("bite")
3. print(my_set) # 结果：{'World', 'bite', 'Hello'}（顺序可能会变）

(2) 移除元素

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

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

1. my_set = {"Hello", "World"}
2. my_set.remove("World")
3. print(my_set) # 结果：{'Hello'}

 (3) 从集合中随机取出元素

语法:集合.pop()，功能，从集合中随机取出一个元素

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

1. my_set = {"Hello", "World"}
2. element = my_set.pop()
3. print(my_set) # 结果：{'Hello'}
4. print(element) # 结果：World

(4) 清空集合

语法:集合.clear()，功能，清空集合

结果:集合本身被清空

1. my_set = {"Hello", "World"}
2. my_set.clear()
3. print(my_set) # 结果：set()

 (5)取出2个集合的差集

语法:集合1.difference(集合2)，功能: 取出集合1和集合2的差集 (集合1有而集合2没有的)

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

1. set1 = {1, 2, 3}
2. set2 = {1, 5, 6}
3. set3 = set1.difference(set2)
4. print(set3) # 结果：{2, 3}
5. print(set2) # 结果：{1, 5, 6}
6. print(set1) # 结果：{1, 2, 3}

(6) 消除2个集合的差集

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

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

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

1. set1 = {1, 2, 3}
2. set2 = {1, 5, 6}
3. set1.difference_update(set2)
4. print(set1) # 结果：{2, 3}
5. print(set2) # 结果：{1, 5, 6}

(7) 2个集合合并

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

功能:将集合1和集合2组合成新集合

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

1. set1 = {1, 2, 3}
2. set2 = {1, 5, 6}
3. set3 = set1.union(set2)
4. print(set3) # 结果：{1, 2, 3, 5, 6}
5. print(set1) # 结果：{1, 2, 3}
6. print(set2) # 结果：{1, 5, 6}

---

二、字典

思考：老师有一份名单，记录了学生的姓名和考试总成绩，现在需要将其通过Python录入至程序中，并可以通过学生姓名检索学生的成绩，由此引入了字典，使用字典可以用key取出 Value的操作

1.字典的定义

字典的定义，同样使用{ }，不过存储的元素是一个个的 : 键值对，如下语法：

1. # 定义字典字面量
2. {key: value, key: value, ......, key: value}
4. # 定义字典变量
5. my_dict = {key: value, key: value, ......, key: valuel}
7. # 定义空字典
8. my_dict = {} # 空字典定义方式1
9. my_dict = dict() # 空字典定义方式2

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

1. # 定义重复Key的宇典
2. my_dict1 = {"王力鸿": 99,"王力鸿": 88,"林俊节": 77}
3. print(f"重复key的字典的内容是:{my_dict1}")
5. # 结果：重复key的字典的内容是:{'王力鸿':88，林俊节':77}

---

2.字典数据的获取

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

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

1. # 语法，字典[Key]可以取到对应的value
2. stu_score = {"李四": 99, "张三": 88,"王二麻子": 77}
3. print(stu_score["李四"]) # 结果：99
4. print(stu_score["张三"]) # 结果：88
5. print(stu_score["王二麻子"]) # 结果：77

---

3.字典的嵌套

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

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

需求如下: 记录学生各科的考试信息

1. stu_score_dict = {
2. "王力鸿": {
3. "语文": 77,
4. "数学": 66,
5. "英语": 33
6. }, "周杰轮": {
7. "语文": 88,
8. "数学": 86,
9. "英语": 55
10. }, "林俊节": {
11. "语文": 99,
12. "数学": 96,
13. "英语": 66
14. }
15. }
16. print(f"学生的考试信息是:{stu_score_dict}")
18. # 结果：学生的考试信息是:{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}

从嵌套字典中获取数据:

1. score = stu_score_dict["周杰轮"]["语文"]
2. print(f"周杰轮的语文分数是:{score}")
4. # 结果：周杰轮的语文分数是:88

---

4.字典的常用操作

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

（1）新增元素

语法:字典[Key] =Value，结果:字典被修改，新增了元素

1. my_dict1 = {"王力鸿": 88, "林俊节": 77}
2. # 新增，张学油的考试成绩
3. my_dict1['张学油'] = 66
4. print(my_dict1)
6. # 结果：{'王力鸿': 88, '林俊节': 77, '张学油': 66}

（2）更新元素

语法:字典[Key]=Value，结果:字典被修改，元素被更新

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

1. my_dict1 = {"王力鸿": 88, "林俊节": 77}
2. my_dict1['王力鸿'] = 66
3. print(my_dict1)
5. # 结果：{'王力鸿': 66, '林俊节': 77}

（3）删除元素

语法: 字典.pop(Key)，结果:获得指定Key的Value，同时字典被修改，指定Key的数据被删除

1. my_dict1 = {"王力鸿": 88, "林俊节": 77}
2. value = my_dict1.pop("王力鸿")
3. print(value) # 结果：88
4. print(my_dict1) # 结果：{'林俊节': 77}

（4）清空字典

语法:字典.clear()，结果:字典被修改，元素被清空

1. my_dict1 = {"王力鸿": 88, "林俊节": 77}
2. my_dict1.clear()
3. print(my_dict1)
5. # 结果：{}

（5）获取字典的全部Key

语法：字典.keys()，可用于for循环遍历字典

1. # 获取全部的key
2. my_dict = {"周杰轮": 99, "王力鸿": 88, "林俊节": 77}
3. keys = my_dict.keys()
4. print(f"字典的全部keys是:{keys}") # 结果：字典的全部keys是:dict_keys(['周杰轮', '王力鸿', '林俊节'])
6. # 遍历字典
7. # 方式一：通过获取到全部的key来完成遍历
8. for key in keys:
9. print(f"字典的key是:{key}")
10. print(f"字典的value是: {my_dict[key]}")
12. # 方式二：直接对字典进行for循环，每一次循环都是直接得到key
13. for key in my_dict:
14. print(f"字典的key是:{key}")
15. print(f"字典的value是: {my_dict[key]}")

---

5.字典的特点

经过上述对字典的学习，可以总结出字典有如下特点:

（1）可以容纳多个数据

（2）可以容纳不同类型的数据

（3）每一份数据是KeyValue键值对

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

（5）不支持下标索引

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

（7）支持for循环，不支持while循环

---

本次内容就到此啦，欢迎评论区或者私信交流，觉得笔者写的还可以，或者自己有些许收获的，麻烦铁汁们动动小手，给俺来个一键三连，万分感谢 !