python中set用法详解

全面掌握Python集合类型的核心用法|高效去重|关系运算|性能优化|实战示例

1 什么是Python中的set?

Python中的set(集合)是一种无序、可变、不重复的容器类型,用于存储唯一元素。其底层实现基于哈希表(Hash Table),支持高效的成员检测、去重与集合运算,是处理数据关系的核心工具。

从数学集合论出发,set严格遵循集合三大特性:

  1. 确定性:任一对象要么在集合中,要么不在,无模糊空间
  2. 互异性:集合中元素互不相同,自动去重
  3. 无序性:元素排列无固定顺序,不支持索引访问

与列表(list)和字典(dict)对比:

类型有序性可变性去重能力典型用途
list有序可变❌顺序存储、频繁索引
dict有序(Python ≥3.7)可变仅键唯一键值映射
set无序可变✅去重、关系运算
frozenset无序不可变✅需哈希的只读集合

尤其在数据清洗、去重、关联分析场景中,set表现远超列表循环判断,是Python高阶编程的必备技能。

2 set的创建方式

创建set需满足两个前提:元素必须是hashable(可哈希),即不可变对象(如int、str、tuple);而list、dict等可变对象不可作为集合元素。

2.1 基础创建:花括号与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)}    # 允许:元组可哈希

2.2 frozenset:不可变集合

当集合需作为字典键或放入其他集合时,必须使用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()),确保数据安全。

3 基本操作与常用方法

掌握set的增删查改是基础,以下方法均通过哈希实现,时间复杂度平均为O(1)。

3.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()

3.2 元素存在性检查

利用哈希特性,in操作效率极高:

s = {10, 20, 30, 40}
print(20 in s)   # True
print(15 in s)   # False

3.3 长度与遍历

s = {1, 2, 3}
len(s)        # 3
# 遍历(无序!)
for x in s:
    print(x)  # 输出顺序可能为 3,1,2 或其他

3.4 高频实战案例

案例1:列表去重(保留原顺序?)

# 方式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](顺序固定)

案例2:文本词频统计基础

text = "Python is great. Python is powerful."
words = text.lower().replace('.', '').split()
unique_words = set(words)
# → {'python', 'is', 'great', 'powerful'}

3.5 集合推导式(Set Comprehension)

语法:{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', '!'}

4 集合运算:关系分析利器

set的核心价值在于集合运算,广泛用于数据交集、差集、并集等场景,是数据清洗与关联分析的基石。

4.1 基础四则运算

并集
交集
差集
对称差集

并集(Union):所有元素的集合

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}

交集(Intersection):共同元素的集合

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

差集(Difference):A中有但B中没有的元素

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}(未活跃用户)

对称差集(Symmetric Difference):非共同元素

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"}(需同步的项)

4.2 子集与超集判断

判断集合关系

方法运算符示例结果
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(无交集)

4.3 修改自身集合(原地操作)

原地更新方法

方法等效运算说明
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}

4.4 集合运算的数学性质

  • 交换律:$A \cup B = B \cup A$,$A \cap B = B \cap A$
  • 结合律:$(A \cup B) \cup C = A \cup (B \cup C)$
  • 分配律:$A \cap (B \cup C) = (A \cap B) \cup (A \cap C)$
  • 德·摩根律:$\overline{A \cup B} = \overline{A} \cap \overline{B}$

这些性质确保集合运算在逻辑上严谨,是算法设计的理论基础。

5 性能深度对比:为何set更高效?

在数据量大时,set的性能优势显著,核心原因在于其底层哈希结构(类似dict的键存储)。

5.1 时间复杂度对比

关键操作复杂度

操作listset说明
成员检测 x in sO(n)O(1) 平均列表需逐个比对;集合通过哈希直接定位
插入 add()—O(1) 平均可能触发扩容,但摊还复杂度O(1)
删除 remove()—O(1) 平均哈希定位后删除
创建 list(set())—O(n)需遍历所有元素

5.2 实测数据(10万级数据)

测试场景:检查1000个随机数是否存在于10万个元素中

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倍

5.3 内存占用权衡

哈希表需预留空间以维持低冲突率,set比list更占内存:

  • 空set:约240字节
  • 空list:约56字节
  • 含1000个整数:set约需80KB,list约需28KB

结论:当内存敏感且无需集合运算时,优先用list;当需频繁去重/关系运算时,用set更优。

6 常见误区与陷阱

即使经验开发者,也易陷入以下陷阱,需特别注意:

6.1 空集合创建错误

初学者常误写:empty = {},但这是空字典!正确方式为empty = set()。

6.2 可变对象作为元素

# ❌ 错误:列表不可哈希
s = {[1,2]}  # TypeError: unhashable type: 'list'
# ✅ 正确:转为元组
s = {(1,2)}  # 允许

6.3 集合无序性导致的误解

集合不保证插入顺序,多次运行结果可能不同:

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']

6.4 混淆并集与连接

对字符串列表用+连接,而非set并集:

# ❌ 错误:set并集会去重
list1 = ['a', 'b']
list2 = ['b', 'c']
merged = list1 + list2  # → ['a','b','b','c'](保留重复)
# ✅ 若需去重合并
merged_unique = list(set(list1 + list2))  # → ['a','b','c'](顺序不定)

6.5 集合运算符优先级

运算符优先级:~ > & > ^ > |,但建议用括号明确:

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}

8 最佳实践总结

✅ 推荐用法

  • 列表去重(尤其大数据量)
  • 快速成员检测(如IP黑名单校验)
  • 关系分析(用户重叠、标签共现)
  • 实现集合论算法(如Jaccard相似度)

❌ 避免场景

  • 需保留元素顺序时(改用dict.fromkeys())
  • 内存极度受限的小数据集
  • 频繁插入/删除但无集合运算需求

⚡ 高阶技巧

  • 用set.add()替代if x not in list: list.append(x)
  • 结合itertools.groupby()实现复杂分组去重
  • 用set.pop()模拟随机抽样(非统计学随机)

备案号:蜀ICP备2026035467号-3

© 2025 python中set用法 | www.xservx.com