Python3 集合 – 菜鸟教程-菜鸟网博客-为草根创业提供网络知识

在 Python 3 中，集合 (Set) 是一种极其强大且独特的内置数据结构。它基于数学中的集合论概念设计，主要用于存储无序且唯一的元素集合。

虽然在日常开发中，列表和字典的使用频率更高，但集合在数据去重、成员资格快速检查以及执行数学集合运算（如交集、并集、差集）时，具有不可替代的性能优势和代码简洁性。

以下是对 Python 3 集合的全面、深度解析，涵盖从基础语法、高级特性、底层原理到最佳实践的完整指南。（本文篇幅较长，旨在提供一份可作为生产环境参考手册的深度指南）

一、集合的核心特性

在深入语法之前，必须牢记集合的四个核心特性，这决定了它的使用场景和限制：

唯一性 (Uniqueness)：集合中的元素不能重复。如果尝试添加已存在的元素，集合会自动忽略，不会报错。
无序性 (Unordered)：集合中的元素没有固定的顺序。你不能通过索引（如 s[0]）来访问元素，每次打印集合时，元素的显示顺序可能不同（取决于哈希值和内存布局）。
可变性 (Mutable)：标准的 set 是可变的，你可以动态地添加或删除元素。
元素必须是可哈希的 (Hashable)：集合底层基于哈希表实现，因此加入集合的元素必须是不可变且可哈希的类型（如整数、浮点数、字符串、元组）。列表、字典和其他集合不能作为集合的元素。

(注：Python 还提供了 frozenset，它是集合的不可变版本，可以作为字典的键或其他集合的元素。)

二、集合的创建与初始化

1. 字面量创建 (最常用)

使用花括号 {} 将元素括起来，元素之间用逗号分隔。

# 包含多个元素的集合 (自动去重)
fruits = {"apple", "banana", "cherry", "apple"}
print(fruits)  # 输出类似: {'cherry', 'apple', 'banana'} (顺序不定，且只有一个 'apple')

# 混合类型的集合
mixed_set = {1, 3.14, "hello", (1, 2)}

2. ⚠️ 核心避坑：空集合的创建

这是 Python 中最经典的陷阱之一。不能使用 {} 来创建空集合，因为 {} 在 Python 中被保留用于创建空字典。

empty_dict = {}
print(type(empty_dict))  # <class 'dict'>

# ✅ 正确做法：使用 set() 构造函数创建空集合
empty_set = set()
print(type(empty_set))   # <class 'set'>

3. 使用 `set()` 构造函数

set() 可以接受任何可迭代对象 (Iterable)（如字符串、列表、元组、字典），并将其转换为集合。这是数据去重最常用的手段。

# 从列表去重
my_list = [1, 2, 2, 3, 3, 3, 4]
unique_set = set(my_list)
print(unique_set)  # {1, 2, 3, 4}

# 从字符串提取唯一字符
chars = set("programming")
print(chars)  # {'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n'}

# 从字典转换 (注意：只提取字典的键，忽略值)
my_dict = {"a": 1, "b": 2, "c": 1}
keys_set = set(my_dict)
print(keys_set)  # {'a', 'b', 'c'}

4. 集合推导式 (Set Comprehension) 🌟

与列表和字典推导式类似，集合推导式提供了一种简洁、高效的方式来生成新集合。

# 基础用法：生成 0-9 中偶数的平方集合
even_squares = {x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # {0, 4, 16, 36, 64}

# 字符串处理：提取所有元音字母并转为大写
text = "hello world"
vowels = {char.upper() for char in text if char in "aeiou"}
print(vowels)  # {'E', 'O'}

三、集合的基本操作 (增、删、查)

由于集合是无序的，它不支持索引访问、切片或修改特定位置的元素。它只支持整体的添加、删除和成员检查。

1. 增加元素 (Add)

s.add(x): 将元素 x 添加到集合中。如果 x 已存在，则不执行任何操作。时间复杂度 $O(1)$。
s.update(iterable): 将另一个可迭代对象中的所有元素添加到集合中。相当于就地执行并集操作。时间复杂度 $O(K)$，K 为新增元素个数。

s = {1, 2, 3}

s.add(4)
print(s)  # {1, 2, 3, 4}

s.add(2)  # 2 已存在，集合不变
print(s)  # {1, 2, 3, 4}

s.update([3, 4, 5, 6])  # 传入列表
print(s)  # {1, 2, 3, 4, 5, 6}

s.update("abc")  # 传入字符串，会被拆分为单个字符
print(s)  # {1, 2, 3, 4, 5, 6, 'a', 'b', 'c'}

2. 删除元素 (Remove)

集合提供了多种删除方式，需根据是否需要处理“元素不存在”的情况来选择：

s.remove(x): 移除元素 x。如果 x 不存在，抛出 KeyError。
s.discard(x): 移除元素 x。如果 x 不存在，什么都不做，不报错。（最推荐的安全删除方式）。
s.pop(): 移除并返回集合中的任意一个元素。如果集合为空，抛出 KeyError。(注：由于集合无序，弹出的元素看似随机，实际上是哈希表底层存储的第一个元素)。
s.clear(): 清空集合中的所有元素。

s = {10, 20, 30}

# discard (安全)
s.discard(20)
print(s)  # {10, 30}
s.discard(99)  # 不会报错

# remove (不安全，需配合 try-except 或 in 检查)
# s.remove(99)  # KeyError: 99

# pop (随机弹出)
popped = s.pop()  
print(popped)  # 10 或 30
print(s)       # 剩下一个元素

3. 查找元素 (Search)

x in s / x not in s: 检查元素是否存在于集合中。这是集合最核心的优势，时间复杂度为 $O(1)$，远快于列表的 $O(N)$。

valid_users = {"alice", "bob", "charlie"}

# ✅ 推荐：极速的成员检查
if "bob" in valid_users:
    print("Access granted")

四、集合的数学运算 (核心应用场景) 🌟

集合最强大的功能在于支持标准的数学集合运算。Python 提供了运算符和方法两种方式。

⚠️ 关键区别：

运算符 (|, &, -, ^)：要求两边都必须是集合类型。
方法 (union(), intersection(), difference(), symmetric_difference())：可以接受任何可迭代对象（如列表、元组），方法内部会自动将其转换为集合再进行运算。

假设有两个集合：

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

1. 并集 (Union)

包含 A 和 B 中的所有唯一元素。

print(A | B)               # {1, 2, 3, 4, 5, 6, 7, 8} (运算符)
print(A.union(B))          # {1, 2, 3, 4, 5, 6, 7, 8} (方法)
print(A.union([6, 7, 8]))  # {1, 2, 3, 4, 5, 6, 7, 8} (方法可接受列表)

# 就地更新 (相当于 A = A | B)
A |= B

2. 交集 (Intersection)

仅包含同时存在于 A 和 B 中的元素。

print(A & B)                     # {4, 5}
print(A.intersection(B))         # {4, 5}
print(A.intersection([4, 5, 9])) # {4, 5}

# 就地更新
A &= B

3. 差集 (Difference)

包含存在于 A 中，但不存在于 B 中的元素。注意：差集是有方向性的，A - B 不等于 B - A。

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

4. 对称差集 (Symmetric Difference)

包含存在于 A 或 B 中，但不同时存在于两者中的元素（即并集减去交集）。

print(A ^ B)                        # {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))    # {1, 2, 3, 6, 7, 8}

# 就地更新
A ^= B

5. 实际应用场景示例：找出两个文件的差异

file1_lines = {"import os", "def main():", "print('Hello')", "x = 1"}
file2_lines = {"import sys", "def main():", "print('Hello')", "y = 2"}

# 找出 file1 中有但 file2 中没有的行 (被删除的代码)
deleted = file1_lines - file2_lines
print("Deleted:", deleted)  # {'x = 1', 'import os'}

# 找出 file2 中有但 file1 中没有的行 (新增的代码)
added = file2_lines - file1_lines
print("Added:", added)      # {'y = 2', 'import sys'}

# 找出两个文件完全不同的行 (对称差集)
changed = file1_lines ^ file2_lines
print("Changed lines:", changed) # {'x = 1', 'import os', 'y = 2', 'import sys'}

— “is a good separator” —

五、集合的关系测试

除了元素级别的运算，集合还支持集合与集合之间的整体关系判断，返回布尔值。

A = {1, 2, 3}
B = {1, 2, 3, 4, 5}
C = {4, 5}

# 1. 子集 (Subset): A 的所有元素是否都在 B 中？
print(A <= B)                # True
print(A.issubset(B))         # True
print(A < B)                 # True (真子集：A 是 B 的子集且 A != B)

# 2. 超集 (Superset): B 是否包含 A 的所有元素？
print(B >= A)                # True
print(B.issuperset(A))       # True
print(B > A)                 # True (真超集)

# 3. 不相交 (Disjoint): 两个集合是否完全没有共同元素？
print(A.isdisjoint(C))       # True (A 和 C 没有交集)
print(B.isdisjoint(C))       # False (B 和 C 有交集 {4, 5})

六、集合的底层原理与性能分析 (深度解析)

理解集合的底层实现，是写出高性能 Python 代码的必经之路。在 CPython 中，集合 (set) 和字典 (dict) 共享几乎相同的底层数据结构：哈希表 (Hash Table)。

1. 为什么集合的查找速度是 $O(1)$？

当你执行 x in my_set 时，Python 不会像列表那样从头到尾遍历（$O(N)$）。它的执行步骤如下：

调用 hash(x) 计算元素 x 的哈希值（一个整数）。
将该哈希值与集合底层数组的大小进行按位与运算（或取模），直接计算出一个内存索引。
跳转到该索引位置，比对存储的元素是否与 x 相等（处理哈希冲突）。
如果相等，返回 True；如果该位置为空，返回 False。

由于直接通过数学计算定位内存地址，无论集合有 10 个元素还是 1000 万个元素，查找时间几乎恒定，即 $O(1)$ 时间复杂度。

2. 集合与字典的底层差异

虽然都基于哈希表，但集合的结构更简单：

字典的哈希表槽位 (Slot) 存储的是：(hash, key, value)。
集合的哈希表槽位存储的是：(hash, key)。集合本质上就是一个只有 Key、没有 Value 的字典。

3. 哈希冲突与开放寻址法

当两个不同的元素计算出相同的哈希索引时（哈希冲突），CPython 使用开放寻址法 (Open Addressing)。它会使用一个伪随机探测序列（基于哈希值的扰动），在底层数组中寻找下一个空闲的槽位来存储该元素。

4. 时间复杂度总结

操作	平均时间复杂度	最坏情况时间复杂度	说明
添加 `s.add(x)`	$O(1)$	$O(N)$	均摊 $O(1)$。当哈希表负载因子过高时，会触发扩容 (Resize)，需重新哈希所有元素，此时为 $O(N)$。
删除 `s.remove(x)`	$O(1)$	$O(N)$	删除时会在原位置插入一个特殊的“哑元 (Dummy)”标记，以维持探测序列的完整性，避免中断后续元素的查找。
查找 `x in s`	$O(1)$	$O(N)$	集合的最大优势。最坏情况发生在极端哈希冲突时（极罕见）。
并集/交集 `s1 \| s2`	$O(len(s1) + len(s2))$	需要遍历两个集合的元素。
遍历 `for x in s`	$O(N)$	$O(N)$	N 为底层哈希表的容量（包含空槽），而非实际元素个数。因此，稀疏的集合遍历会比紧凑的集合稍慢。

5. 内存占用分析

为了保持较低的哈希冲突率（通常负载因子保持在 2/3 以下），集合的底层数组必须预留大量空槽位。因此，集合的内存占用通常远大于包含相同元素的列表。

import sys

my_list = list(range(1000))
my_set = set(range(1000))

print(sys.getsizeof(my_list))  # 约 8856 bytes
print(sys.getsizeof(my_set))   # 约 32768 bytes (大约是列表的 3-4 倍)

结论：集合是用空间换取时间的典型数据结构。当内存不是瓶颈，且需要频繁进行成员检查或去重时，使用集合是绝对正确的选择。

七、核心避坑指南与最佳实践

1. 陷阱：尝试添加不可哈希 (Unhashable) 的对象

集合要求其元素必须是可哈希的。列表、字典、集合本身都是可变的，因此不可哈希。

s = {1, 2, 3}

# ❌ 错误：列表不可哈希
# s.add([4, 5])  # TypeError: unhashable type: 'list'

# ✅ 正确：将列表转换为元组 (元组是可哈希的)
s.add((4, 5))
print(s)  # {1, 2, 3, (4, 5)}

2. 陷阱：在迭代集合时修改集合

与字典类似，在 for 循环遍历集合时，如果添加或删除元素，会改变底层哈希表的结构，导致 RuntimeError: Set changed size during iteration。

s = {1, 2, 3, 4, 5}

# ❌ 错误做法
# for item in s:
#     if item % 2 == 0:
#         s.remove(item)  # RuntimeError

# ✅ 正确做法 1：遍历集合的列表副本
for item in list(s):
    if item % 2 == 0:
        s.remove(item)

# ✅ 正确做法 2：使用集合推导式创建新集合 (更 Pythonic)
s = {item for item in s if item % 2 != 0}

3. 陷阱：误以为 `pop()` 是 LIFO 或 FIFO

由于集合无序，s.pop() 弹出的元素是“任意”的（实际上是哈希表底层数组中遇到的第一个有效元素）。不要依赖 pop() 来获取“最后一个”或“第一个”加入的元素。如果需要有序的弹出，请使用 list 或 collections.deque。

4. `frozenset` 的妙用：嵌套集合与字典键

如果你需要一个不可变的集合，可以使用 frozenset。它支持所有非修改性的集合操作（如交集、并集、查找），但不能 add 或 remove。

# 1. 作为字典的键 (普通 set 不行)
allowed_permissions = frozenset({"read", "write"})
role_mapping = {
    frozenset({"read"}): "Guest",
    frozenset({"read", "write"}): "Editor",
    allowed_permissions: "Admin"
}
print(role_mapping[allowed_permissions])  # Admin

# 2. 创建“集合的集合” (普通 set 的元素不能是 set)
set_of_sets = {
    frozenset({1, 2}),
    frozenset({3, 4}),
    frozenset({1, 2})  # 自动去重
}
print(set_of_sets)  # {frozenset({1, 2}), frozenset({3, 4})}

5. 性能优化：列表转集合进行大规模查找

如果你有一个包含百万级数据的列表，需要频繁检查某个元素是否在其中，务必先将其转换为集合。

import time

# 模拟百万级数据
big_list = list(range(1000000))
big_set = set(big_list)

target = 999999

# ❌ 列表查找：O(N)，需要遍历近百万次
start = time.time()
_ = target in big_list
print(f"List lookup time: {time.time() - start:.6f} seconds")  # 约 0.01-0.02 秒

# ✅ 集合查找：O(1)，瞬间完成
start = time.time()
_ = target in big_set
print(f"Set lookup time: {time.time() - start:.6f} seconds")   # 约 0.000001 秒 (快上万倍)

八、总结

Python 3 的集合 (set) 是一个设计精妙、性能卓越的数据结构。它不仅仅是一个“去重工具”，更是执行高效成员检查和复杂数学集合运算的利器。

语法层面：推导式、丰富的运算符 (|, &, -, ^) 以及关系测试方法，使得集合操作的代码极具可读性，宛如在编写数学公式。
底层层面：基于高度优化的哈希表实现，以适度的内存开销换取了 $O(1)$ 的极速查找和插入性能。
应用层面：从简单的列表去重 (list(set(my_list)))，到复杂的权限校验、数据差异比对，集合都能提供最优雅的解决方案。

核心口诀：

需要唯一性和快速查找时，首选 set。
需要保持顺序或通过索引访问时，使用 list。
需要键值映射时，使用 dict。
需要不可变的集合（如作为字典的键）时，使用 frozenset。

熟练掌握集合的特性和底层逻辑，将极大提升你编写 Python 代码的效率、性能和优雅度。如果你对集合在特定算法（如广度优先搜索 BFS 中的 visited 集合）或大规模数据处理（如 Pandas 中的集合操作）中的应用有疑问，欢迎随时深入探讨！

一、 集合的核心特性

二、 集合的创建与初始化

1. 字面量创建 (最常用)

2. ⚠️ 核心避坑：空集合的创建

3. 使用 set() 构造函数

4. 集合推导式 (Set Comprehension) 🌟

三、 集合的基本操作 (增、删、查)

1. 增加元素 (Add)

2. 删除元素 (Remove)

3. 查找元素 (Search)

四、 集合的数学运算 (核心应用场景) 🌟

1. 并集 (Union)

2. 交集 (Intersection)

3. 差集 (Difference)

4. 对称差集 (Symmetric Difference)

5. 实际应用场景示例：找出两个文件的差异

五、 集合的关系测试

六、 集合的底层原理与性能分析 (深度解析)

1. 为什么集合的查找速度是 $O(1)$？

2. 集合与字典的底层差异

3. 哈希冲突与开放寻址法

4. 时间复杂度总结

5. 内存占用分析

七、 核心避坑指南与最佳实践

1. 陷阱：尝试添加不可哈希 (Unhashable) 的对象

2. 陷阱：在迭代集合时修改集合

3. 陷阱：误以为 pop() 是 LIFO 或 FIFO

4. frozenset 的妙用：嵌套集合与字典键

5. 性能优化：列表转集合进行大规模查找

八、 总结

Written by lichongyang

You might also like

Python3 命名空间和作用域

Python3 面向对象

Python3 错误和异常