【大模型2609·Python基础·05】数据容器精讲（下）：集合Set与字典Dict深度剖析

专栏导读：本篇攻克基于哈希算法的无序容器：集合（Set）与字典（Dict）。系统解析集合去重、交并差补运算，全面剖析字典的键值对存储模型、安全查询方法（get/setdefault）及动态操作，最后通过多维对照表横向对比四大容器的性能特点与最佳选型场景。

5.3 集合（无序可变{}）

  • 集合是无序的，且不包含重复元素。
  • 集合使用 {} 定义，数据之间使用 , 分隔，也可以使用set()定义。
  • 集合没有索引，所以不能通过切片方式访问集合元素。
  • 集合中元素可以是不同的类型。
  • 集合可以进行数学上的集合操作，如并集、交集和差集。
  • 集合适用于需要快速成员检查、消除重复项和集合运算的场景。

5.3.1 创建集合

1
2
3
4
5
6
7
8
9
10
11
# 创建集合
set_demo1 = set() # 创建空集合
print("set_demo1：", set_demo1)
set_demo2 = {1,2,3,4,5} # {}代表集合
print("set_demo2：", set_demo2)
set_demo3 = {x for x in range(1,11)} # 集合推导式
print("set_demo3：",set_demo3)
set_demo4 = set("hello world") # 字符串转换集合
print("set_demo4：",set_demo4)
set_demo5 = set(range(1,11)) # 使用range创建集合
print("set_demo5：",set_demo5)

5.3.2 与序列的对比

特性 序列 集合
顺序 有序，保持插入顺序 无序
重复元素 允许重复 自动去重
索引/切片 支持（seq[0], seq[1:3]） 不支持
内存使用 通常更节省 通常更大（哈希表实现）
查找效率 O(n) 线性查找 O(1) 平均查找时间
可变性 有可变和不可变类型 有可变和不可变类型

5.3.3 容器相同的操作

  • 检查元素x是否为容器中的成员：x in container
  • 获取容器的长度：len(container)
  • 遍历容器：for x in container:
  • 容器：找最大值max(container)、最小值min(container)
  • 容器元素求累加和：sum(container) 要求元素是数值类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 检查成员是否为集合中的元素
setDemo = {1, 2, 3, 4, 5}
print(f"1 in {setDemo}：", 1 in setDemo)

# 获取集合的长度
setDemo = {1, 2, 3, 4, 5}
print("集合的长度", len(setDemo))

# 遍历集合
setDemo = {1, 2, 3, 4, 5}
for num in setDemo:
    print(num, end=" ")
print()

# 找最大值max(sequence)、最小值min(sequence)、总和
setDemo = {4, 1, 3, 2, 5}
print(f"集合{setDemo}的最大值：", max(setDemo))
print(f"集合{setDemo}的最小值：", min(setDemo))
print(f"集合{setDemo}的总和：", sum(setDemo))

5.3.4 向集合中添加元素

1
2
3
4
5
6
7
# 向集合中添加元素
setDemo = {1, 2, 3, 4, 5}
print(f"集合{setDemo}")
setDemo.add(6)
print(f"添加元素6：", setDemo)
setDemo.update([7, 8, 9])
print(f"添加元素[7, 8, 9]：", setDemo)

5.3.5 从集合中删除元素

  • remove(目标元素)：目标元素存在时删除元素，目标元素不存在时报错
  • discard(目标元素)：目标元素存在时删除元素，目标元素不存在时安静的忽略
  • pop()：删除集合中的第一个元素

在不确定元素是否存在的场景下，推荐使用 discard() 以避免程序中断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 删除集合中的元素
setDemo = {1, 2, 3, 4, 5}
print(f"集合{setDemo}")
setDemo.remove(3)
print(f"删除元素3：", setDemo)
# setDemo.remove(6) # 抛出 KeyError: 6
setDemo.discard(4)
print(f"删除元素4：", setDemo)
setDemo.discard(6)  # 不报错，集合保持不变
print(f"删除元素6：", setDemo)
setDemo.pop()
print(f"删除集合中的第一个元素：", setDemo)
setDemo.clear()
print(f"清空集合：", setDemo)

5.3.6 差集、并集、交集计算

1
2
3
4
5
6
# 集合判断
setDemo1 = {1, 2, 3}
setDemo2 = {1, 2, 3, 7, 8}
print("setDemo1和setDemo2是否完全不同，没有交集：",setDemo1.isdisjoint(setDemo2))
print("setDemo1是setDemo2的子集吗：",setDemo1.issubset(setDemo2))
print("setDemo1是setDemo2的父集吗：",setDemo1.issuperset(setDemo2))
1
2
3
4
5
6
7
# 集合运算符
setDemo1 = {1, 2, 3, 4, 5}
setDemo2 = {1, 2, 3, 7, 8}
print(f"{setDemo1} | {setDemo2} 并集 = ",setDemo1 | setDemo2)  # 集合的并集
print(f"{setDemo1} & {setDemo2} 交集 = ",setDemo1 & setDemo2)  # 集合的交集
print(f"{setDemo1} - {setDemo2} 差集 = ",setDemo1 - setDemo2)  # 集合的差集
print(f"{setDemo1} ^ {setDemo2} 异或集 = ",setDemo1 ^ setDemo2)  # 集合的异或集
1
2
3
4
5
6
7
8
# 集合并集计算
setDemo1 = {1, 2, 3, 4, 5}
setDemo2 = {1, 2, 3, 7, 8}
setDemo3 = {1, 2, 3, 5, 6}
print("setDemo1集合 = ", setDemo1)
print("setDemo2集合 = ", setDemo2)
print("setDemo3集合 = ", setDemo3)
print("setDemo1.union(setDemo2,setDemo3)并集 = ",setDemo1.union(setDemo2,setDemo3)) # 集合的并集，setDemo1集合不变，返回新集合
1
2
3
4
5
6
7
8
9
10
11
# 集合交集计算
setDemo1 = {1, 2, 3, 4, 5}
setDemo2 = {1, 2, 3, 7, 8}
setDemo3 = {1, 2, 3, 5, 6}
print("setDemo1集合 = ", setDemo1)
print("setDemo2集合 = ", setDemo2)
print("setDemo3集合 = ", setDemo3)
print("setDemo1.intersection(setDemo2,setDemo3)交集 = ",setDemo1.intersection(setDemo2,setDemo3)) # 集合的交集，setDemo1集合不变，返回新集合
print("setDemo1.intersection(setDemo2,setDemo3)计算交集后setDemo1 = ",setDemo1)
setDemo1.intersection_update(setDemo2,setDemo3) # 集合的交集，setDemo1集合被修改，返回None
print("setDemo1.intersection(setDemo2,setDemo3)计算交集后setDemo1 = ",setDemo1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 集合差集计算
setDemo1 = {1, 2, 3, 4, 5}
setDemo2 = {1, 2, 3, 7, 8}
setDemo3 = {1, 2, 3, 5, 6}
print("setDemo1集合 = ", setDemo1)
print("setDemo2集合 = ", setDemo2)
print("setDemo3集合 = ", setDemo3)
#  difference和difference_update：用于计算差集（即当前集合中存在但其他集合中不存在的元素）
print("setDemo1.difference(setDemo2,setDemo3)的差集",setDemo1.difference(setDemo2,setDemo3)) # 集合的差集，setDemo1集合不变，返回新集合
print("setDemo1.difference(setDemo2,setDemo3)计算差集后setDemo1 =", setDemo1)
setDemo1.difference_update(setDemo2,setDemo3) # 集合的差集，setDemo1集合被修改，返回None
print("setDemo1.difference_update(setDemo2,setDemo3)计算差集后setDemo1 = ", setDemo1)

# symmetric_difference和symmetric_difference_update：用于计算两个集合的对称差集（即只存在于其中一个集合中的元素）
setDemo1 = {1, 2, 3, 4, 5}
setDemo2 = {1, 2, 3, 7, 8}
print("setDemo1.symmetric_difference(setDemo2)差集 = " ,setDemo1.symmetric_difference(setDemo2)) # 集合的对称差集，setDemo1集合不变，返回新集合
print("setDemo1.symmetric_difference(setDemo2)计算差集后setDemo1 =", setDemo1)
setDemo1.symmetric_difference_update(setDemo2) # 集合的对称差集，setDemo1集合被修改，返回None
print("setDemo1.symmetric_difference_update(setDemo2)计算差集后setDemo1 = ", setDemo1)

5.4 字典（键值对{}）

  • 一个无序的键值对集合，键是唯一的，而值可以重复。
  • 字典使用 {} 定义，键（key）和值（value）使用 : 连接，每个键值对之间使用 , 分隔。如{key1 : value1, key2 : value2}
  • 字典没有索引。
  • 字典可以通过键来获取对应的值。
  • 值可以取任何数据类型，但键必须是不可变的，如字符串、数字、元组。

5.4.1 创建字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建字典
dict1 = {} # 创建空字典
print("dict1：", dict1)

dict2 = dict() # 创建空字典
print("dict2：", dict2)

dict3 = {"name": "Irene", "age": 18, "sex": "female"}
print("dict3：", dict3)

dict4 = dict(name="Bob", age=20, gender="female")
print("dict4：", dict4)

dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
print("dict5：", dict5)

dict6 = {x: x**2 for x in range(4)}
print("dict6：", dict6)

5.4.2 获取字典的长度

1
2
3
# 获取字典长度
dictDemo = {"name": "Irene", "age": 18, "sex": "female"}
print("字典的长度：", len(dictDemo))

5.4.3 检查key是否存在

1
2
3
4
# 检查成员是否为字典中的key
dictDemo = {"name": "Irene", "age": 18, "sex": "female"}
print(f"name in {dictDemo}：", "name" in dictDemo) # 可以检查key
print(f"Irene in {dictDemo}：", "Irene" in dictDemo) # 无法检查value

5.4.4 根据key获取value

1
2
3
4
5
6
7
8
9
10
# 根据key获取value
dictDemo = {"name": "Irene", "age": 18, "sex": "female"}
print(f"{dictDemo['name']} 的年龄是：", dictDemo["age"])
print(f"{dictDemo['name']} 的性别是：", dictDemo["sex"])
# print(f"{dictDemo['name']} 的电话是：", dictDemo["tel"]) # KeyError: 'tel'

print(f"{dictDemo.get('name')}的年龄是", dictDemo.get("age"))
print(f"{dictDemo.get('name')}的性别是", dictDemo.get("sex"))
print(f"{dictDemo.get('name')}的电话是", dictDemo.get("tel")) # None

5.4.5 向字典添加元素

1
2
3
4
5
6
# 向字典中添加元素
dictDemo = {"name": "Irene", "age": 18, "sex": "female"}
dict_demo["tel"] = "1234567890"
print("添加tel：", dict_demo)
dict_demo.update({"email": "[email protected]"})
print("添加email：", dict_demo)

5.4.5 修改value

1
2
3
4
5
6
dict_demo = {"name": "Irene", "age": 18, "sex": "female"}
# 修改
dict_demo["name"] = "lily"
print("修改name：", dict_demo)
dict_demo.update({"name": "lucy"})
print("修改name：", dict_demo)

5.4.6 删除字典元素

1
2
3
4
5
6
7
8
9
10
11
# 删除字典元素
dictDemo = {"name": "Irene", "age": 18, "sex": "female", 'tel': '1234567890', 'email': '[email protected]'}
# 删除
dict_demo.pop("name")
print("删除name：", dict_demo)
dict_demo.popitem()
print("删除最后一个元素：", dict_demo)
del dict_demo["age"]
print("删除age：", dict_demo)
dict_demo.clear()
print("清空字典：", dict_demo)

5.4.7遍历字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dict_demo = {"name": "Irene", "age": 18, "sex": "female"}
# 遍历
print("遍历所有key：",end=" ")
for key in dict_demo:
    print(key, end=" ")
print()

print("遍历所有value：",end=" ")
for value in dict_demo.values():
    print(value, end=" ")
print()

print("遍历所有键值对：")
for key,value in dict_demo.items():
    print(key,"->", value)

5.4.8 常用函数

函数 说明
del dict[key] 根据key删除键值对
dict.pop(key[,default]) 获取key所对应的value，同时删除该键值对，可设置默认值
dict.popitem() 取出字典中的最后插入的键值对，字典为空则报错
dict.clear() 清空字典
dict1.update(dict2) 将dict2中的键值对更新到dict1中
dict.get(key[,default]) 获取字典中key对应value，可设置默认值
dict.setdefault(key[,default]) 获取字典中key对应value，可设置默认值。若key不存在于字典中，将会添加key并将value设为默认值
dict.keys() 获取字典所有的key，返回一个视图对象。字典改变，视图也会跟着变化
dict.values() 获取字典所有的value，返回一个视图对象
dict.items() 获取字典所有的(key,value)，返回一个视图对象
dict.copy() 拷贝字典
dict.fromkeys(seq[,default]) 以序列seq中元素做字典的key创建一个新字典，可设置value的默认值

5.5 列表、元组、集合、字典区别

数据结构 是否可变 是否重复 是否有序 定义符号
列表（List） 可变 允许 有序 []或list()
元组（Tuple） 不可变 允许 有序 ()或tuple()
字典（Dictionary） 可变 键不允许，值允许 键无序（Python 3.7+版本中保持插入顺序） {}或dict()
集合（Set） 可变 不允许 无序 {}或set()