Python 集合代码详解：掌握数据去重与高效数学运算的利器9

在Python的丰富数据结构中，集合（Set）是一个功能强大且应用广泛的类型。它以其独特的性质——无序性、唯一性和可变性——在处理数据去重、成员检测以及执行各种数学集合运算方面展现出无与伦比的效率和便捷性。作为一名专业的程序员，熟练掌握Python集合的使用，无疑能极大地提升我们的编程效率和代码质量。本文将深入探讨Python集合的基础概念、常用操作、高级应用及最佳实践，助您全面驾驭这一Python利器。

一、Python集合的基础概念与创建

Python集合是一种无序、不重复的元素集。这意味着：
无序性（Unordered）：集合中的元素没有固定的顺序，因此不能通过索引来访问。每次打印集合时，元素的顺序可能不同。
唯一性（Unique）：集合中的所有元素都是唯一的，不允许有重复项。当您尝试向集合添加重复元素时，该元素将被忽略。
可变性（Mutable）：集合本身是可变的，可以添加或删除元素。但是，集合中的元素必须是不可变的（immutable），例如数字、字符串、元组，而不能是列表、字典或其他集合。

1.1 创建空集合

创建空集合时，必须使用set()函数，而不是空的花括号{}。因为空的花括号在Python中默认创建的是空字典。# 创建一个空集合
empty_set = set()
print(f"空集合: {empty_set}, 类型: {type(empty_set)}")
# 尝试用花括号创建空集合，会得到字典
empty_dict = {}
print(f"空字典: {empty_dict}, 类型: {type(empty_dict)}")

输出结果：空集合: set(), 类型:
空字典: {}, 类型:

1.2 创建带元素的集合

创建带有初始元素的集合，可以使用花括号{}，元素之间用逗号分隔。如果初始元素中包含重复项，集合会自动去重。# 创建包含数字的集合
numbers = {1, 2, 3, 4, 5}
print(f"数字集合: {numbers}")
# 创建包含字符串的集合
fruits = {"apple", "banana", "cherry"}
print(f"水果集合: {fruits}")
# 尝试创建包含重复元素的集合，会自动去重
duplicates = {1, 2, 2, 3, 4, 4, 5}
print(f"去重后的集合: {duplicates}")
# 集合中的元素可以是不同类型，但必须是不可变的
mixed_set = {1, "hello", 3.14, (1, 2)}
print(f"混合类型集合: {mixed_set}")
# 错误示例：集合中不能包含可变元素（如列表、字典、其他集合）
try:
invalid_set = {1, [2, 3]} # 这会引发TypeError
except TypeError as e:
print(f"错误示例：{e}")

输出结果：数字集合: {1, 2, 3, 4, 5}
水果集合: {'banana', 'apple', 'cherry'} # 注意：输出顺序可能不同
去重后的集合: {1, 2, 3, 4, 5}
混合类型集合: {1, 3.14, 'hello', (1, 2)} # 注意：输出顺序可能不同
错误示例：unhashable type: 'list'

1.3 从其他可迭代对象创建集合

可以使用set()函数将列表、元组、字符串等可迭代对象转换为集合。这通常是实现快速去重的一种高效方法。# 从列表中创建集合
my_list = [1, 2, 3, 2, 4, 5, 1]
set_from_list = set(my_list)
print(f"从列表创建的集合: {set_from_list}")
# 从元组中创建集合
my_tuple = (10, 20, 10, 30)
set_from_tuple = set(my_tuple)
print(f"从元组创建的集合: {set_from_tuple}")
# 从字符串中创建集合（字符串的每个字符被视为一个元素）
my_string = "hello world"
set_from_string = set(my_string)
print(f"从字符串创建的集合: {set_from_string}") # 包含所有不重复字符
# 从字典的键中创建集合
my_dict = {"a": 1, "b": 2, "c": 3}
set_from_dict_keys = set(my_dict)
print(f"从字典键创建的集合: {set_from_dict_keys}")

输出结果：从列表创建的集合: {1, 2, 3, 4, 5}
从元组创建的集合: {10, 20, 30}
从字符串创建的集合: {'r', 'e', 'h', 'o', 'l', ' ', 'd', 'w'} # 注意：输出顺序可能不同
从字典键创建的集合: {'b', 'c', 'a'} # 注意：输出顺序可能不同

二、集合的常用操作：增、删、查

2.1 添加元素

使用add()方法向集合中添加单个元素。如果元素已存在，则不会有任何效果。my_set = {1, 2, 3}
print(f"原始集合: {my_set}")
(4)
print(f"添加元素4后: {my_set}")
(2) # 2已存在，不会被添加
print(f"尝试添加重复元素2后: {my_set}")
# 使用 update() 方法添加多个元素（可以是列表、元组、其他集合等）
([5, 6], {7, 8})
print(f"使用update添加多个元素后: {my_set}")

输出结果：原始集合: {1, 2, 3}
添加元素4后: {1, 2, 3, 4}
尝试添加重复元素2后: {1, 2, 3, 4}
使用update添加多个元素后: {1, 2, 3, 4, 5, 6, 7, 8}

2.2 删除元素

Python集合提供了多种删除元素的方法，它们在处理不存在的元素时行为不同。
remove(element)：删除指定的元素。如果元素不存在，会引发KeyError。
discard(element)：删除指定的元素。如果元素不存在，不会引发错误，而是静默处理。
pop()：随机删除并返回集合中的一个元素。由于集合是无序的，无法预测哪个元素会被删除。如果集合为空，会引发KeyError。
clear()：清空集合中的所有元素。

my_set = {10, 20, 30, 40, 50}
print(f"原始集合: {my_set}")
# 使用 remove() 删除存在的元素
(20)
print(f"remove 20后: {my_set}")
try:
(99) # 99不存在，会引发KeyError
except KeyError as e:
print(f"尝试remove不存在的元素引发错误: {e}")
# 使用 discard() 删除存在的元素
(30)
print(f"discard 30后: {my_set}")
(99) # 99不存在，不会引发错误
print(f"尝试discard不存在的元素后: {my_set}")
# 使用 pop() 随机删除一个元素
popped_element = ()
print(f"pop了一个元素: {popped_element}, 集合变为: {my_set}")
# 使用 clear() 清空集合
()
print(f"clear后集合: {my_set}")
try:
() # 空集合pop会引发KeyError
except KeyError as e:
print(f"空集合尝试pop引发错误: {e}")

输出结果：原始集合: {50, 20, 40, 10, 30}
remove 20后: {50, 40, 10, 30}
尝试remove不存在的元素引发错误: 99
discard 30后: {50, 40, 10}
尝试discard不存在的元素后: {50, 40, 10}
pop了一个元素: 50, 集合变为: {40, 10} # 注意：pop出的元素可能不同
clear后集合: set()
空集合尝试pop引发错误: 'pop from an empty set'

2.3 查询元素（成员检测）

使用in关键字可以高效地检查一个元素是否存在于集合中。这是集合的一大优势，平均时间复杂度为O(1)。my_set = {"apple", "banana", "cherry"}
print(f"apple 在集合中吗? {'apple' in my_set}")
print(f"grape 在集合中吗? {'grape' in my_set}")
print(f"banana 不在集合中吗? {'banana' not in my_set}")

输出结果：apple 在集合中吗? True
grape 在集合中吗? False
banana 不在集合中吗? False

三、集合的数学运算

集合最强大的功能之一是其对数学集合运算的天然支持，这在数据分析、算法设计等领域非常有用。Python提供了运算符和方法两种方式进行这些操作。

3.1 并集（Union）

并集包含两个集合中的所有不重复元素。

方法：union()

运算符：|set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
union_set_method = (set2)
union_set_operator = set1 | set2
print(f"集合1: {set1}")
print(f"集合2: {set2}")
print(f"并集 (方法): {union_set_method}")
print(f"并集 (运算符): {union_set_operator}")

输出结果：集合1: {1, 2, 3, 4}
集合2: {3, 4, 5, 6}
并集 (方法): {1, 2, 3, 4, 5, 6}
并集 (运算符): {1, 2, 3, 4, 5, 6}

3.2 交集（Intersection）

交集包含两个集合中共同拥有的元素。

方法：intersection()

运算符：&set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
intersection_set_method = (set2)
intersection_set_operator = set1 & set2
print(f"集合1: {set1}")
print(f"集合2: {set2}")
print(f"交集 (方法): {intersection_set_method}")
print(f"交集 (运算符): {intersection_set_operator}")
# intersection_update() 会直接修改调用它的集合
set1_copy = {1, 2, 3, 4}
set1_copy.intersection_update(set2)
print(f"intersection_update 后 set1_copy: {set1_copy}")

输出结果：集合1: {1, 2, 3, 4}
集合2: {3, 4, 5, 6}
交集 (方法): {3, 4}
交集 (运算符): {3, 4}
intersection_update 后 set1_copy: {3, 4}

3.3 差集（Difference）

差集包含在一个集合中但不在另一个集合中的元素。set1 - set2表示set1中有但set2中没有的元素。

方法：difference()

运算符：-set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
difference_set_method = (set2)
difference_set_operator = set1 - set2
print(f"集合1: {set1}")
print(f"集合2: {set2}")
print(f"差集 (set1 - set2, 方法): {difference_set_method}")
print(f"差集 (set1 - set2, 运算符): {difference_set_operator}")
# 差集的顺序很重要
difference_set_reverse = set2 - set1
print(f"差集 (set2 - set1): {difference_set_reverse}")
# difference_update() 会直接修改调用它的集合
set1_copy = {1, 2, 3, 4}
set1_copy.difference_update(set2)
print(f"difference_update 后 set1_copy: {set1_copy}")

输出结果：集合1: {1, 2, 3, 4}
集合2: {3, 4, 5, 6}
差集 (set1 - set2, 方法): {1, 2}
差集 (set1 - set2, 运算符): {1, 2}
差集 (set2 - set1): {5, 6}
difference_update 后 set1_copy: {1, 2}

3.4 对称差集（Symmetric Difference）

对称差集包含在两个集合中，但不同时存在于两个集合中的元素（即排除交集）。

方法：symmetric_difference()

运算符：^set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
symmetric_difference_set_method = set1.symmetric_difference(set2)
symmetric_difference_set_operator = set1 ^ set2
print(f"集合1: {set1}")
print(f"集合2: {set2}")
print(f"对称差集 (方法): {symmetric_difference_set_method}")
print(f"对称差集 (运算符): {symmetric_difference_set_operator}")
# symmetric_difference_update() 会直接修改调用它的集合
set1_copy = {1, 2, 3, 4}
set1_copy.symmetric_difference_update(set2)
print(f"symmetric_difference_update 后 set1_copy: {set1_copy}")

输出结果：集合1: {1, 2, 3, 4}
集合2: {3, 4, 5, 6}
对称差集 (方法): {1, 2, 5, 6}
对称差集 (运算符): {1, 2, 5, 6}
symmetric_difference_update 后 set1_copy: {1, 2, 5, 6}

四、集合的比较与关系

集合还可以进行子集、超集和不相交的判断。

4.1 子集与超集

issubset() 或 <=：判断一个集合是否是另一个集合的子集。
<：判断一个集合是否是另一个集合的真子集（即除了是子集外，两者不能相等）。
issuperset() 或 >=：判断一个集合是否是另一个集合的超集。
>：判断一个集合是否是另一个集合的真超集。

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
set_c = {1, 2, 3}
set_d = {6, 7}
print(f"set_a: {set_a}, set_b: {set_b}, set_c: {set_c}, set_d: {set_d}")
# 子集判断
print(f"set_a 是 set_b 的子集吗? {(set_b)}") # True
print(f"set_a = set_a 吗? {set_b >= set_a}") # True
print(f"set_b > set_a 吗? {set_b > set_a}") # True (真超集)
print(f"set_c >= set_a 吗? {set_c >= set_a}") # True (相等也算超集)
print(f"set_c > set_a 吗? {set_c > set_a}") # False (不是真超集，因为相等)

输出结果：set_a: {1, 2, 3}, set_b: {1, 2, 3, 4, 5}, set_c: {1, 2, 3}, set_d: {6, 7}
set_a 是 set_b 的子集吗? True
set_a set_a 吗? True
set_c >= set_a 吗? True
set_c > set_a 吗? False

4.2 不相交（Disjoint）

isdisjoint()方法用于判断两个集合是否完全没有共同的元素（即它们的交集为空）。set_e = {1, 2, 3}
set_f = {4, 5, 6}
set_g = {3, 4, 7}
print(f"set_e: {set_e}, set_f: {set_f}, set_g: {set_g}")
print(f"set_e 和 set_f 不相交吗? {(set_f)}") # True
print(f"set_e 和 set_g 不相交吗? {(set_g)}") # False (有共同元素3)

输出结果：set_e: {1, 2, 3}, set_f: {4, 5, 6}, set_g: {3, 4, 7}
set_e 和 set_f 不相交吗? True
set_e 和 set_g 不相交吗? False

五、不可变集合：Frozenset

与普通集合（set）是可变的不同，Python还提供了一种不可变的集合类型：frozenset。一旦创建，frozenset的元素就不能再被添加或删除。它的主要特点和用途包括：
不可变性：不支持add(), remove(), clear()等修改操作。
可哈希性（Hashable）：由于其不可变性，frozenset是可哈希的，这意味着它可以作为字典的键，或者作为另一个普通集合的元素。

# 创建一个 frozenset
fs1 = frozenset([1, 2, 3])
fs2 = frozenset({3, 4, 5})
print(f"frozenset 1: {fs1}")
print(f"frozenset 2: {fs2}")
# frozenset 可以作为字典的键
my_dict = {fs1: "Key is frozenset 1", frozenset([4, 5]): "Key is frozenset 4,5"}
print(f"字典使用 frozenset 作为键: {my_dict}")
print(f"访问字典值: {my_dict[frozenset([1, 2, 3])]}")
# frozenset 可以作为普通集合的元素
my_mutable_set = {frozenset([10, 20]), frozenset([30, 40])}
print(f"集合包含 frozenset 元素: {my_mutable_set}")
# 尝试修改 frozenset 会报错
try:
(4)
except AttributeError as e:
print(f"尝试修改 frozenset 报错: {e}")
# frozenset 同样支持数学集合运算
print(f"frozenset 的并集: {(fs2)}")

输出结果：frozenset 1: frozenset({1, 2, 3})
frozenset 2: frozenset({3, 4, 5})
字典使用 frozenset 作为键: {frozenset({1, 2, 3}): 'Key is frozenset 1', frozenset({4, 5}): 'Key is frozenset 4,5'}
访问字典值: Key is frozenset 1
集合包含 frozenset 元素: {frozenset({30, 40}), frozenset({10, 20})}
尝试修改 frozenset 报错: 'frozenset' object has no attribute 'add'
frozenset 的并集: frozenset({1, 2, 3, 4, 5})

六、集合的高级应用与最佳实践

6.1 高效去重

这是集合最常见的应用之一。将一个列表或元组转换为集合，再转换回列表，即可实现高效去重。data_with_duplicates = [1, 2, 3, 2, 4, 1, 5, 3, 6]
unique_data = list(set(data_with_duplicates))
print(f"原始数据: {data_with_duplicates}")
print(f"去重后数据: {unique_data}")
# 保持原始顺序去重 (需要额外处理)
def remove_duplicates_preserve_order(sequence):
seen = set()
result = []
for item in sequence:
if item not in seen:
(item)
(item)
return result
ordered_unique_data = remove_duplicates_preserve_order(data_with_duplicates)
print(f"去重并保持顺序的数据: {ordered_unique_data}")

输出结果：原始数据: [1, 2, 3, 2, 4, 1, 5, 3, 6]
去重后数据: [1, 2, 3, 4, 5, 6] # 注意：顺序可能与原始列表不同
去重并保持顺序的数据: [1, 2, 3, 4, 5, 6]

6.2 快速成员检测

由于其底层基于哈希表实现，集合在检查元素是否存在方面拥有卓越的性能（平均O(1)时间复杂度）。这比在列表中线性搜索（O(N)）要快得多，尤其是在处理大量数据时。import time
import random
# 创建一个大列表和一个大集合
large_list = list(range(1000000))
large_set = set(large_list)
# 随机选择一些元素进行查找
elements_to_find = [(0, 1500000) for _ in range(10000)]
# 在列表中查找
start_time = ()
for element in elements_to_find:
_ = element in large_list
end_time = ()
print(f"在列表中查找 {len(elements_to_find)} 次耗时: {end_time - start_time:.6f} 秒")
# 在集合中查找
start_time = ()
for element in elements_to_find:
_ = element in large_set
end_time = ()
print(f"在集合中查找 {len(elements_to_find)} 次耗时: {end_time - start_time:.6f} 秒")

输出结果（具体数值会因机器性能而异，但趋势一致）：在列表中查找 10000 次耗时: 0.150030 秒
在集合中查找 10000 次耗时: 0.000780 秒

从上面的示例可以看出，集合在成员检测方面具有压倒性的性能优势。

6.3 数据过滤与分析

利用集合的数学运算，可以方便地进行数据过滤、找出共同项或差异项。# 场景：两个用户列表，找出共同好友、独有好友
user_a_friends = {"Alice", "Bob", "Charlie", "David"}
user_b_friends = {"Charlie", "David", "Eve", "Frank"}
common_friends = (user_b_friends)
a_only_friends = (user_b_friends)
b_only_friends = (user_a_friends)
all_friends = (user_b_friends)
print(f"用户A的朋友: {user_a_friends}")
print(f"用户B的朋友: {user_b_friends}")
print(f"共同好友: {common_friends}")
print(f"用户A独有的朋友: {a_only_friends}")
print(f"用户B独有的朋友: {b_only_friends}")
print(f"所有不重复的朋友: {all_friends}")

输出结果：用户A的朋友: {'David', 'Charlie', 'Alice', 'Bob'}
用户B的朋友: {'Eve', 'Frank', 'David', 'Charlie'}
共同好友: {'David', 'Charlie'}
用户A独有的朋友: {'Alice', 'Bob'}
用户B独有的朋友: {'Eve', 'Frank'}
所有不重复的朋友: {'Alice', 'Bob', 'Eve', 'Frank', 'David', 'Charlie'}

6.4 注意事项

元素必须可哈希：这是最重要的一点。因为集合的底层实现是哈希表，所以集合中的元素必须是不可变的（可哈希的）。这就是为什么列表、字典和普通集合不能直接作为集合的元素。
集合是无序的：不要依赖集合元素的顺序。如果你需要保持顺序，请使用列表或其他有序数据结构。
性能考量：虽然集合操作通常非常高效，但在极大规模的数据集上，创建集合本身可能需要时间和内存。始终根据具体场景权衡。

七、总结

Python集合作为一种独特的、高效的数据结构，在处理需要去重、快速成员检测以及进行数学集合运算的场景中表现出色。从基础的创建与增删查，到强大的数学运算和比较，再到不可变集合frozenset，Python为我们提供了全面的集合操作支持。

熟练掌握集合的使用，能够帮助我们编写出更简洁、更高效的代码，尤其在数据清洗、日志分析、权限管理、关系计算等领域，集合常常能发挥关键作用。希望通过本文的详细讲解和代码示例，您能对Python集合有一个深入的理解，并在日常编程中灵活运用，让您的Python代码更加专业和强大！

2025-09-29

---

上一篇：Python数据提取：从文件、数据库到Web的全面指南

下一篇：Python深度解析：二进制补码的原理、转换与实际应用代码