Python高级数据类型：集合（Set）

集合是Python中一种非常有用的数据结构，它与列表类似但具有独特的特性。本文将全面介绍集合的所有知识点，从基础概念到高级用法，帮助初学者彻底掌握集合的使用。

1. 集合简介

1.1 什么是集合？

集合（Set）是Python中的一种无序、不重复元素的容器。它类似于数学中的集合概念，具有以下主要特点：

元素唯一性：集合中的元素不会重复
无序性：元素没有固定顺序
可变性：可以添加或删除元素
元素不可变性：集合中的元素必须是不可变类型（如数字、字符串、元组等）

1.2 为什么需要集合？

集合主要解决两个问题：

去重：自动去除重复元素
关系运算：高效执行集合运算（交集、并集、差集等）

2. 集合的创建与基本操作

2.1 创建集合

# 方法1：使用花括号（注意与字典的区别）
s1 = {1, 2, 3, 2, 1}  # 自动去重，结果为{1, 2, 3}# 方法2：使用set()构造函数
s2 = set()  # 创建空集合
s3 = set([1, 2, 3, 2, 1])  # 从列表创建，结果为{1, 2, 3}# 方法3：从字符串创建（会拆分为字符）
s4 = set("hello")  # 结果为{'h', 'e', 'l', 'o'}

注意：创建空集合必须使用set()，因为{}表示空字典。

2.2 集合的元素特性

集合中的元素必须满足：

不可变：不能是列表、字典、集合等可变类型
可哈希：必须实现__hash__方法

合法元素示例：

valid_set = {1, "hello", (1, 2, 3), True, 3.14}

非法元素示例：

invalid_set = {[1, 2], {"a": 1}, {1, 2}}  # 会报TypeError

2.3 集合的去重特性

集合自动去除重复元素：

numbers = [1, 2, 3, 2, 1, 4, 5, 4]
unique_numbers = set(numbers)  # 结果为{1, 2, 3, 4, 5}

3. 集合的基本操作

3.1 添加元素

s = {1, 2, 3}# 添加单个元素
s.add(4)  # s变为{1, 2, 3, 4}# 添加多个元素
s.update([5, 6, 7])  # s变为{1, 2, 3, 4, 5, 6, 7}
s.update({8, 9}, [10, 11])  # 可以混合添加

3.2 删除元素

s = {1, 2, 3, 4, 5, 6}# 方法1：remove() - 删除指定元素，不存在则报错
s.remove(3)  # s变为{1, 2, 4, 5, 6}# 方法2：discard() - 删除指定元素，不存在不报错
s.discard(10)  # 无变化# 方法3：pop() - 随机删除并返回一个元素
item = s.pop()  # 随机删除一个元素# 方法4：clear() - 清空集合
s.clear()  # s变为set()

3.3 查询操作

s = {1, 2, 3, 4, 5}# 检查元素是否存在
print(3 in s)  # 输出: True
print(6 not in s)  # 输出: True# 获取集合长度
print(len(s))  # 输出: 5

3.4 集合的不可修改性

集合中的元素不能直接修改，因为集合是基于哈希表实现的。如果需要"修改"元素，只能先删除再添加：

s = {1, 2, 3}# 错误做法（会报错）
# s[0] = 10  # 正确做法：先删除再添加
s.remove(1)
s.add(10)  # s变为{2, 3, 10}

4. 集合的关系运算

集合最强大的功能之一是能够执行数学上的集合运算。

4.1 交集（Intersection）

返回两个集合中都存在的元素。

s1 = {1, 2, 3}
s2 = {2, 3, 4}# 方法1：使用&运算符
print(s1 & s2)  # 输出: {2, 3}# 方法2：使用intersection()方法
print(s1.intersection(s2))  # 输出: {2, 3}

4.2 并集（Union）

返回两个集合中所有不重复的元素。

# 方法1：使用|运算符
print(s1 | s2)  # 输出: {1, 2, 3, 4}# 方法2：使用union()方法
print(s1.union(s2))  # 输出: {1, 2, 3, 4}

4.3 差集（Difference）

返回只存在于第一个集合中的元素。

# 方法1：使用-运算符
print(s1 - s2)  # 输出: {1}
print(s2 - s1)  # 输出: {4}# 方法2：使用difference()方法
print(s1.difference(s2))  # 输出: {1}

4.4 对称差集（Symmetric Difference）

返回两个集合中不相同的元素（即只存在于其中一个集合中的元素）。

# 方法1：使用^运算符
print(s1 ^ s2)  # 输出: {1, 4}# 方法2：使用symmetric_difference()方法
print(s1.symmetric_difference(s2))  # 输出: {1, 4}

4.5 子集与超集

判断一个集合是否完全包含于或包含另一个集合。

a = {1, 2, 3}
b = {1, 2}# 子集判断
print(b < a)  # 输出: True（b是a的真子集）
print(b <= a)  # 输出: True（b是a的子集或相等）# 超集判断
print(a > b)  # 输出: True（a是b的真超集）
print(a >= b)  # 输出: True（a是b的超集或相等）# 方法形式
print(b.issubset(a))  # 输出: True
print(a.issuperset(b))  # 输出: True

4.6 集合相等性

判断两个集合是否包含相同的元素（不考虑顺序）。

x = {1, 2, 3}
y = {3, 2, 1}print(x == y)  # 输出: True
print(x != y)  # 输出: False

5. 集合的高级用法

5.1 集合推导式

类似于列表推导式，可以快速生成集合。

# 基本语法
{expression for item in iterable}
{expression for item in iterable if condition}# 示例1：创建平方数集合
squares = {x**2 for x in range(10)}
# 输出: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}# 示例2：筛选偶数平方
even_squares = {x**2 for x in range(10) if x % 2 == 0}
# 输出: {0, 4, 16, 36, 64}# 示例3：字符串处理
words = ["hello", "world", "python"]
unique_chars = {char for word in words for char in word}
# 输出: {'d', 'e', 'h', 'l', 'n', 'o', 'p', 'r', 't', 'w', 'y'}

5.2 冻结集合（frozenset）

frozenset是不可变集合，可以作为字典的键或另一个集合的元素。

fs = frozenset([1, 2, 3, 2, 1])  # 创建冻结集合# 可以作为字典的键
d = {fs: "frozen set"}  # 合法# 可以作为集合的元素
s = {fs, frozenset([4, 5, 6])}  # 合法

5.3 集合与列表的转换

# 列表去重（常用技巧）
lst = [1, 2, 3, 2, 1, 4, 5, 4]
unique_lst = list(set(lst))  # 转换为集合去重，再转回列表# 注意：顺序可能改变
print(unique_lst)  # 可能输出: [1, 2, 3, 4, 5]

5.4 集合的性能优势

集合基于哈希表实现，查找操作时间复杂度为O(1)，远快于列表的O(n)。

# 查找元素性能比较
big_list = list(range(1000000))
big_set = set(big_list)# 列表查找（慢）
%timeit 999999 in big_list  # 约10ms# 集合查找（快）
%timeit 999999 in big_set  # 约100ns

6. 集合的实际应用场景

6.1 数据去重

# 去除重复单词
text = "hello world hello python world"
words = text.split()
unique_words = set(words)  # {'hello', 'world', 'python'}

6.2 关系测试

# 找出共同好友
alice_friends = {"Bob", "Charlie", "Diana"}
bob_friends = {"Alice", "Charlie", "Eve"}common_friends = alice_friends & bob_friends  # {'Charlie'}

6.3 成员快速查找

# 高效检查元素是否存在
valid_users = {"alice", "bob", "charlie"}
username = input("请输入用户名: ")
if username in valid_users:print("欢迎回来！")
else:print("用户名不存在")

6.4 过滤数据

# 筛选出只出现一次的元素
from collections import Counterdata = [1, 2, 3, 2, 1, 4, 5, 4, 6]
counts = Counter(data)
unique_elements = {x for x in data if counts[x] == 1}  # {3, 5, 6}

7. 集合与其他数据结构的比较

特性	集合(set)	列表(list)	字典(dict)
有序性	无序	有序	Python 3.7+有序
元素唯一性	唯一	可重复	键唯一
可变性	可变	可变	可变
元素类型	必须不可变	任意	键必须不可变，值任意
查找速度	O(1)	O(n)	O(1)
主要用途	去重、关系运算	有序数据存储	键值对映射

8. 常见问题与解答

Q1: 为什么集合是无序的？

集合基于哈希表实现，为了快速查找（O(1)时间复杂度），元素存储位置由哈希值决定，因此不保持插入顺序。

注意：Python 3.7+中，集合实际上保持了插入顺序，但这被视为实现细节，不应依赖。

Q2: 集合和字典有什么关系？

集合相当于只有键没有值的字典。实际上，Python的集合就是使用字典实现的，只是所有值都是None。

Q3: 如何选择使用列表还是集合？

需要保持顺序或允许重复 → 使用列表
需要快速查找或去重 → 使用集合
需要关系运算 → 使用集合

Q4: 为什么集合的元素必须是不可变的？

因为集合基于哈希表实现，可变对象无法生成固定哈希值，会导致集合内部结构混乱。

9. 练习题

练习1：去重统计

# 统计一段文本中不同单词的数量
text = """Python is an easy to learn powerful programming language.
It has efficient high-level data structures and a simple but effective
approach to object-oriented programming. Python is easy to learn."""words = text.split()
unique_words = set(words)
print(f"不同单词数量: {len(unique_words)}")

练习2：共同兴趣

# 找出两个人的共同兴趣
alice_interests = {"reading", "hiking", "coding", "movies"}
bob_interests = {"coding", "movies", "gaming", "cooking"}common_interests = alice_interests & bob_interests
print(f"共同兴趣: {common_interests}")

练习3：集合运算

# 给定三个集合，找出只在A中出现的元素
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7}
C = {5, 6, 7, 8}result = A - (B | C)
print(f"只在A中的元素: {result}")

10. 总结

集合是Python中非常有用的数据结构，主要特点包括：

元素唯一性：自动去重
无序性：元素没有固定顺序
高效查找：基于哈希表实现，查找速度O(1)
关系运算：支持交集、并集、差集等数学运算
元素限制：只能包含不可变类型

掌握集合的使用可以：

简化去重操作
提高查找效率
实现复杂的关系运算
优化程序性能

建议在实际编程中多尝试使用集合，特别是需要去重或快速查找的场景。