Python之集合set
简记录一下Python中的set集合,这里介绍一下相关基础知识,记录于此,方便自己查阅。
正文
set
集合set是:“一个无序的、元素互不相同的可哈希对象集合。”
set是可哈希:set 里的“元素”必须可哈希
特征
| 特征 | 说明 | 对比列表 list |
|---|---|---|
| 无序 | 不记录元素位置,也不记录插入顺序 | list 有顺序 |
| 不重复 | 相同元素只能存在一个 | list 允许重复 |
| 元素必须可哈希 | 只能放不可变对象(数字、字符串、元组等) | list 什么都能放 |
| 可变的(set) | 创建后可以增删元素 | tuple 不可变 |
可哈希(hashable) 对象创建后就不能再改变,可以算出固定不变的“哈希值”,,比如int、float、str、tuple 都是可哈希的;list、dict、set自身是可变的,因此不可以可哈希。
# 集合会自动去掉重复元素
fruits = {"苹果", "香蕉", "苹果", "橘子", "香蕉"}
print(fruits) # 输出:{'苹果', '橘子', '香蕉'}(顺序可能不同,重复项没了)
print(type(fruits)) # <class 'set'>创建集合
使用花括号 {}
s1 = {1, 2, 3, 4}
s2 = {"猫", "狗", "兔"}使用 set() 构造函数
s3 = set() # 空集合(注意:不是 {}!)
s4 = set([1, 2, 2, 3, 3, 3]) # 从列表创建,自动去重 → {1, 2, 3}
s5 = set("hello") # 从字符串创建 → {'h', 'e', 'l', 'o'}(l 只保留一个)
s6 = set((1, 2, 3)) # 从元组创建集合推导式
# 语法和列表推导式类似,只是把 [] 换成 {}
squares = {x * x for x in range(6)}
print(squares) # 例如:{0, 1, 4, 9, 16, 25}空集合只能用 set()
a = {} # 这是 空字典 dict,不是集合!
b = set() # 这才是 空集合 set
print(type(a)) # <class 'dict'>
print(type(b)) # <class 'set'>{} 在 Python里已经被字典先用了,所以创建空集合必须用 set()
场见使用
成员判断
skills = {"Python", "SQL", "Excel"}
print("Python" in skills) # True
print("Java" not in skills) # True列表判断成员是逐个比对的(慢),集合判断是“直接算位置”(快)。成员检测的平均时间复杂度是 O(1),数据量越大,优势越明显。
获取长度
print(len(skills)) # 3遍历集合
for skill in skills:
print(skill)
# 注意:输出的顺序是不确定的,每次运行可能不同集合不支持索引和切片!
s = {1, 2, 3}
# print(s[0]) # TypeError: 'set' object is not subscriptable
# print(s[1:3]) # 同样报错因为集合无序,所以没有“第几个元素”的概念,自然不能索引或切片。
增删改
| 方法 | 作用 | 元素不存在时 |
|---|---|---|
| add(elem) | 添加一个元素 | 无异常,直接加入 |
| update(*iterables) | 批量添加(可传多个可迭代对象) | — |
| remove(elem) | 删除一个元素 | 抛出 KeyError |
| discard(elem) | 删除一个元素 | 不报错(推荐) |
| pop() | 随机删除并返回一个元素 | 集合为空时抛 KeyError |
| clear() | 清空所有元素 | — |
| copy() | 浅拷贝一个新集合 | — |
s = {1, 2, 3}
s.add(4) # {1, 2, 3, 4}
s.update([5, 6], {7, 8}) # 批量添加 → {1, 2, 3, 4, 5, 6, 7, 8}
s.remove(3) # {1, 2, 4, 5, 6, 7, 8}
# s.remove(99) # KeyError: 99(元素不存在会报错)
s.discard(99) # 不会报错,安静地什么都不做(推荐日常用这个)
x = s.pop() # 随机弹出一个元素,你不知道是哪个
print(x, s)
s.clear() # set()remove vs discard 怎么选?
确定元素一定存在 → 用 remove
不确定元素是否存在 → 用 discard(不会崩)
大多数场景推荐 discard,更安全。
数学运算
笔记常见,也是笔记特殊的。
每种运算都有运算符写法和方法写法两种方式。
a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}交集(Intersection)—— 两个集合的共同元素
print(a & b) # {4, 5}
print(a.intersection(b)) # {4, 5}并集(Union)—— 两个集合的所有元素(自动去重)
print(a | b) # {1, 2, 3, 4, 5, 6, 7, 8}
print(a.union(b)) # 同上差集(Difference)—— 在 a 中但不在 b 中的元素
print(a - b) # {1, 2, 3}(a 有 b 没有的)
print(b - a) # {6, 7, 8}(b 有 a 没有的,注意方向!)
print(a.difference(b)) # {1, 2, 3}差集有方向性**:a - b ≠ b - a,这和交集、并集不同。
对称差集(Symmetric Difference)—— 只在一个集合里出现的元素
print(a ^ b) # {1, 2, 3, 6, 7, 8}
print(a.symmetric_difference(b)) # 同上
# 等价于 (a - b) | (b - a)关系判断
c = {1, 2}
print(c.issubset(a)) # True —— c 是 a 的子集
print(a.issuperset(c)) # True —— a 是 c 的超集
print(a.isdisjoint(b)) # False —— a 和 b 有交集(不相交才返回 True)
print(c <= a) # True —— 子集
print(c < a) # True —— 真子集(c 是 a 的子集且不相等)
print(a >= c) # True —— 超集速查表
| 运算 | 运算符 | 方法 | 含义 |
|---|---|---|---|
| 交集 | & | .intersection() | 取共同元素 |
| 并集 | | | .union() | 合并去重 |
| 差集 | - | .difference() | 前者有、后者没有 |
| 对称差集 | ^ | .symmetric_difference() | 只在一方出现的 |
| 子集 | <= | .issubset() | 是否全部包含 |
| 超集 | >= | .issuperset() | 是否全部被包含 |
| 不相交 | — | .isdisjoint() | 交集是否为空 |
运算符
上面的运算都会返回新集合,不改变原来的集合。如果想直接修改原集合,用带等号的版本:
s = {1, 2, 3}
s |= {3, 4, 5} # 等同于 s.update({3,4,5}),s 变成 {1,2,3,4,5}
s &= {2, 3, 4} # 等同于 s.intersection_update(...),s 变成 {2,3,4}
s -= {2} # 等同于 s.difference_update(...),s 变成 {3,4}
s ^= {4, 5, 6} # 等同于 s.symmetric_difference_update(...),s 变成 {3,5,6}| 原地运算符 | 等价方法 |
|---|---|
| s |= other | s.update(other) |
| s &= other | s.intersection_update(other) |
| s -= other | s.difference_update(other) |
| s ^= other | s.symmetric_difference_update(other) |
方法 vs 运算符
运算符版本(&、|、-、^)要求两边都是集合,而方法版本(.union() 等)可以接受任意可迭代对象(列表、字符串、元组等)。
s = {1, 2, 3}
# 方法版本:可以传列表,没问题
print(s.union([3, 4, 5])) # {1, 2, 3, 4, 5}
# 运算符版本:必须两边都是 set,否则报错
# print(s | [3, 4, 5]) # TypeError: unsupported operand type(s)
print(s | {3, 4, 5}) # ✅ 正确写法frozenset
frozenset不可变的集合,前面说的都是可变的 set。Python 还提供了不可变版本 frozenset:
| 对比 | set | frozenset |
|---|---|---|
| 可变 | ✅ 可以增删 | ❌ 创建后不可修改 |
| 可哈希 | ❌ | ✅ |
| 能当字典的 key | ❌ | ✅ |
| 能作为集合的元素 | ❌ | ✅ |
| 有 add/remove 等方法 | ✅ | ❌ |
fs = frozenset([1, 2, 3, 1])
print(fs) # frozenset({1, 2, 3})
# fs.add(4) # AttributeError: 'frozenset' object has no attribute 'add'
# frozenset 可以作为字典的 key
d = {frozenset({1, 2}): "一组", frozenset({3, 4}): "二组"}
print(d[frozenset({1, 2})]) # 一组
# frozenset 可以作为集合的元素(实现"集合的集合")
nested = {frozenset({1, 2}), frozenset({3, 4})}
print(nested) # {frozenset({1, 2}), frozenset({3, 4})}当 set 和 frozenset 混合运算时,结果的类型和第一个操作数一致。
print(frozenset({1, 2}) | {2, 3}) # frozenset({1, 2, 3}) —— 结果是 frozenset
print({1, 2} | frozenset({2, 3})) # {1, 2, 3} —— 结果是 set小结
set 是 Python 里一个无序、去重、元素可哈希的容器,最擅长三件事——去重、快速判断成员、集合运算;空集合用 set();方法版运算比运算符版更宽容(接受任意可迭代对象);需要不可变集合时用 frozenset。掌握了这些,你就已经把 set 用到了 90% 的实际场景里。
经典场景
场景 1:快速去重
names = ["小明", "小红", "小明", "小刚", "小红"]
unique_names = list(set(names)) # 先转集合去重,再转回列表
print(unique_names) # 顺序不确定,例如 ['小刚', '小明', '小红']
# 如果需要保持原来的顺序(Python 3.7+ 字典有序,可用 dict.fromkeys)
unique_ordered = list(dict.fromkeys(names))
print(unique_ordered) # ['小明', '小红', '小刚'] ✅ 顺序保留场景 2:快速判断元素是否存在
# 假设有 100 万个合法用户 ID
valid_ids = set(range(1_000_000))
print(999_999 in valid_ids) # True,瞬间完成,比列表快很多场景 3:找出两个列表的共同元素(交集)
# 用户 A 和用户 B 共同关注的博主
a_follows = {"博主1", "博主2", "博主3", "博主4"}
b_follows = {"博主3", "博主4", "博主5", "博主6"}
common = a_follows & b_follows
print(common) # {'博主3', '博主4'}场景 4:找出只在一个列表中出现的元素(对称差集)
# 对比两个版本的文件列表,找出哪些文件只在其中一个版本里
v1_files = {"a.py", "b.py", "c.py"}
v2_files = {"b.py", "c.py", "d.py"}
changed = v1_files ^ v2_files
print(changed) # {'a.py', 'd.py'}常见坑点
集合没有顺序,pop() 弹出的是“任意元素”
s = {1, 2, 3}
print(s.pop()) # 可能是 1、2 或 3,你无法确定集合不能排序,也不能比较大小
# 集合只支持 ==、!= 以及子集/超集比较(<=、>=、<、>)
# 不支持 >、< 这种“按大小排序”的比较
a, b = {1, 2}, {2, 3}
# a < b # False(因为它们不是子集关系)
# sorted(a, b) # 对集合列表排序结果是未定义的空集合判断用 if s:
s = set()
if not s:
print("集合是空的") # 会执行集合的元素是“去重”的,但去重的依据是可哈希性
# 1 和 1.0 被认为是同一个元素(因为它们的哈希值相同)
s = {1, 1.0, 2}
print(s) # {1, 2}(1 和 1.0 被视为相等,只保留一个)参考文章
AI
