全面掌握Python集合类型的核心用法|高效去重|关系运算|性能优化|实战示例
Python中的set(集合)是一种无序、可变、不重复的容器类型,用于存储唯一元素。其底层实现基于哈希表(Hash Table),支持高效的成员检测、去重与集合运算,是处理数据关系的核心工具。
从数学集合论出发,set严格遵循集合三大特性:
与列表(list)和字典(dict)对比:
| 类型 | 有序性 | 可变性 | 去重能力 | 典型用途 |
|---|---|---|---|---|
list | 有序 | 可变 | ❌ | 顺序存储、频繁索引 |
dict | 有序(Python ≥3.7) | 可变 | 仅键唯一 | 键值映射 |
set | 无序 | 可变 | ✅ | 去重、关系运算 |
frozenset | 无序 | 不可变 | ✅ | 需哈希的只读集合 |
尤其在数据清洗、去重、关联分析场景中,set表现远超列表循环判断,是Python高阶编程的必备技能。
创建set需满足两个前提:元素必须是hashable(可哈希),即不可变对象(如int、str、tuple);而list、dict等可变对象不可作为集合元素。
set()构造函数# 花括号创建(元素间用逗号分隔)
s1 = {1, 2, 3, 2} # 自动去重 → {1, 2, 3}
s2 = {'a', 'b', 'a', 'c'} → {'a', 'b', 'c'}
# set()构造函数(从可迭代对象创建)
s3 = set([1, 2, 3, 2]) # 传入列表 → {1, 2, 3}
s4 = set("hello") # 传入字符串 → {'h', 'e', 'l', 'o'}
s5 = set((1, 2, 3, 2)) # 传入元组 → {1, 2, 3}
# ❌ 空集合不能用 {} 创建(那是空字典!)
empty = {} # 类型为 dict
type(empty) # → <class 'dict'>
# ✅ 正确创建空集合
empty_set = set() # 类型为 set
type(empty_set) # → <class 'set'>
# ❌ 尝试添加可变对象(报 TypeError)
s = {1, [2, 3]} # TypeError: unhashable type: 'list'
s = {{1}, {2}} # TypeError: unhashable type: 'set'
# ✅ 可用不可变嵌套
s = {(1, 2), (3, 4)} # 允许:元组可哈希
当集合需作为字典键或放入其他集合时,必须使用frozenset(冻结集合):
# 创建不可变集合
fs = frozenset([1, 2, 3, 2]) # → frozenset({1, 2, 3})
# 支持作为dict的键
d = {fs: "immutable_set_key"}
print(d[frozenset([1, 2, 3])]) # → "immutable_set_key"
# ❌ 普通set不可作为键
d = {{1,2}: "error"} # TypeError: unhashable type: 'set'
frozenset支持所有set的只读操作(如len()、in、运算),但禁止修改方法(如add()、update()),确保数据安全。
掌握set的增删查改是基础,以下方法均通过哈希实现,时间复杂度平均为O(1)。
| 方法 | 功能 | 示例 |
|---|---|---|
add(x) | 添加单个元素 | s.add(5) |
update(iter) | 批量添加(并集操作) | s.update([6,7]) |
remove(x) | 删除元素(不存在则报错) | s.remove(5) |
discard(x) | 删除元素(不存在不报错) | s.discard(5) |
pop() | 随机弹出并返回元素 | x = s.pop() |
clear() | 清空所有元素 | s.clear() |
利用哈希特性,in操作效率极高:
s = {10, 20, 30, 40}
print(20 in s) # True
print(15 in s) # False
s = {1, 2, 3}
len(s) # 3
# 遍历(无序!)
for x in s:
print(x) # 输出顺序可能为 3,1,2 或其他
# 方式1:直接转set去重(丢失顺序)
data = [1, 2, 2, 3, 1, 4]
unique = list(set(data)) # → [1, 2, 3, 4](顺序不定)
# 方式2:保留首次出现顺序(推荐!)
seen = set()
unique_ordered = []
for item in data:
if item not in seen:
seen.add(item)
unique_ordered.append(item)
# → [1, 2, 3, 4](顺序固定)
text = "Python is great. Python is powerful."
words = text.lower().replace('.', '').split()
unique_words = set(words)
# → {'python', 'is', 'great', 'powerful'}
语法:{expression for item in iterable [if condition]}
# 生成1~100中能被3整除的数的集合
div3 = {x for x in range(1,101) if x % 3 == 0}
# → {3, 6, 9, ..., 99}
# 生成字符串中所有字母的小写形式集合(去重)
letters = {c.lower() for c in "Hello, World!"}
# → {'h', 'e', 'l', 'o', ',', ' ', 'w', 'r', 'd', '!'}
set的核心价值在于集合运算,广泛用于数据交集、差集、并集等场景,是数据清洗与关联分析的基石。
A = {1, 2, 3}
B = {3, 4, 5}
# 方法1:运算符 |
C = A | B # → {1, 2, 3, 4, 5}
# 方法2:union()方法
C = A.union(B, {6,7}) # 支持多集合:→ {1,2,3,4,5,6,7}
典型应用:合并多个数据源的唯一ID列表
user_ids_db1 = {101, 102, 103}
user_ids_db2 = {103, 104, 105}
all_users = user_ids_db1 | user_ids_db2
# → {101, 102, 103, 104, 105}
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 方法1:运算符 &
C = A & B # → {3, 4}
# 方法2:intersection()方法
C = A.intersection(B) # → {3, 4}
典型应用:找出两组用户共同关注的标签
tags_userA = {"python", "AI", "web"}
tags_userB = {"web", "python", "data"}
common_tags = tags_userA & tags_userB
# → {"python", "web"}
A = {1, 2, 3, 4}
B = {3, 4, 5}
# A - B:A中独有
C = A - B # → {1, 2}
# B - A:B中独有
D = B - A # → {5}
# 方法:difference()
C = A.difference(B) # → {1, 2}
典型应用:检测新增/缺失用户
all_users = {1, 2, 3, 4, 5}
active_users = {2, 3, 5}
inactive_users = all_users - active_users
# → {1, 4}(未活跃用户)
A = {1, 2, 3}
B = {3, 4, 5}
# 方法1:运算符 ^
C = A ^ B # → {1, 2, 4, 5}
# 方法2:symmetric_difference()
C = A.symmetric_difference(B) # → {1, 2, 4, 5}
数学定义:$(A - B) \cup (B - A)$
典型应用:数据同步时识别变更项
old_data = {"a", "b", "c"}
new_data = {"b", "c", "d"}
changed_items = old_data ^ new_data
# → {"a", "d"}(需同步的项)
| 方法 | 运算符 | 示例 | 结果 |
|---|---|---|---|
issubset() | A <= B | {1,2}.issubset({1,2,3}) | True |
issuperset() | A >= B | {1,2,3}.issuperset({1,2}) | True |
isdisjoint() | 无 | {1,2}.isdisjoint({3,4}) | True(无交集) |
| 方法 | 等效运算 | 说明 |
|---|---|---|
A.update(B) | A |= B | 并集更新:A = A ∪ B |
A.intersection_update(B) | A &= B | 交集更新:A = A ∩ B |
A.difference_update(B) | A -= B | 差集更新:A = A - B |
A.symmetric_difference_update(B) | A ^= B | 对称差集更新:A = A ^ B |
A = {1, 2, 3}
A &= {2, 3, 4} # A = {2, 3}
A.update({5}) # A = {2, 3, 5}
这些性质确保集合运算在逻辑上严谨,是算法设计的理论基础。
在数据量大时,set的性能优势显著,核心原因在于其底层哈希结构(类似dict的键存储)。
| 操作 | list | set | 说明 |
|---|---|---|---|
成员检测 x in s | O(n) | O(1) 平均 | 列表需逐个比对;集合通过哈希直接定位 |
插入 add() | — | O(1) 平均 | 可能触发扩容,但摊还复杂度O(1) |
删除 remove() | — | O(1) 平均 | 哈希定位后删除 |
创建 list(set()) | — | O(n) | 需遍历所有元素 |
import time
# 生成测试数据
n = 100000
test_list = list(range(n))
test_set = set(test_list)
test_items = [i for i in range(1000, 2000)]
# 测试list:O(n) × 1000次
start = time.perf_counter()
for x in test_items:
_ = x in test_list
list_time = time.perf_counter() - start
# 测试set:O(1) × 1000次
start = time.perf_counter()
for x in test_items:
_ = x in test_set
set_time = time.perf_counter() - start
print(f"list耗时: {list_time:.4f}s | set耗时: {set_time:.4f}s | 提升: {list_time/set_time:.1f}倍")
# 典型输出:list耗时: 0.1250s | set耗时: 0.0002s | 提升: 625.0倍
哈希表需预留空间以维持低冲突率,set比list更占内存:
set:约240字节list:约56字节set约需80KB,list约需28KB结论:当内存敏感且无需集合运算时,优先用list;当需频繁去重/关系运算时,用set更优。
即使经验开发者,也易陷入以下陷阱,需特别注意:
初学者常误写:empty = {},但这是空字典!正确方式为empty = set()。
# ❌ 错误:列表不可哈希
s = {[1,2]} # TypeError: unhashable type: 'list'
# ✅ 正确:转为元组
s = {(1,2)} # 允许
集合不保证插入顺序,多次运行结果可能不同:
s = set()
s.add('a'); s.add('b'); s.add('c')
print(s) # 可能输出 {'c', 'a', 'b'} 或任意顺序
解决方案:若需有序去重,用dict.fromkeys()(Python ≥3.7):
data = ['a', 'b', 'a', 'c']
ordered_unique = list(dict.fromkeys(data)) # → ['a', 'b', 'c']
对字符串列表用+连接,而非set并集:
# ❌ 错误:set并集会去重
list1 = ['a', 'b']
list2 = ['b', 'c']
merged = list1 + list2 # → ['a','b','b','c'](保留重复)
# ✅ 若需去重合并
merged_unique = list(set(list1 + list2)) # → ['a','b','c'](顺序不定)
运算符优先级:~ > & > ^ > |,但建议用括号明确:
A = {1,2}; B = {2,3}; C = {3,4}
# ❌ 易错:A & B | C 等价于 (A & B) | C
result = A & B | C # → {2,3,4}
# ✅ 明确:A & (B | C)
result = A & (B | C) # → {2}
dict.fromkeys())set.add()替代if x not in list: list.append(x)itertools.groupby()实现复杂分组去重set.pop()模拟随机抽样(非统计学随机)