集合是Python中用于存储唯一元素且无序的数据结构，支持高效去重和成员检测。它可通过花括号或set()函数创建，能执行交集、并集、差集等数学运算。集合元素必须为不可变类型（如数字、字符串、元组），不可变集合frozenset可作为字典键或嵌套在其他集合中。使用时需注意：{}创建的是字典而非集合，空集合应使用set()；集合无序，不支持索引；频繁成员查找时性能优于列表。适用于去重、权限验证、数据关系分析等场景。
Python里的集合（set）是一种非常独特的数据结构，它最大的特点就是存储的元素都是独一无二的，而且没有固定的顺序。你可以用它来快速去重、进行数学上的交集、并集等操作，非常适合处理需要保持元素唯一性的场景。
解决方案
在Python中，集合的使用其实非常直观，它就像我们数学课上学的集合概念一样。我个人觉得，集合最吸引人的地方就是它天生自带的“去重”能力，这在很多数据清洗的场景下简直是神来之笔。
创建集合：创建集合有两种主要方式。如果你有一堆元素，想直接把它们变成集合，可以这样：
# 直接使用花括号创建集合，元素会自动去重my_set = {1, 2, 3, 2, 1, 4}print(my_set) # 输出: {1, 2, 3, 4} (顺序可能不同)# 从列表、元组等可迭代对象创建集合another_set = set([5, 6, 6, 7])print(another_set) # 输出: {5, 6, 7}# 创建一个空集合，注意不能直接用 {}，因为那会创建一个空字典empty_set = set()print(empty_set) # 输出: set()
添加和删除元素：集合是可变的，你可以随时往里面添加或删除元素。
my_set = {1, 2, 3}# 添加单个元素my_set.add(4)my_set.add(2) # 尝试添加已存在的元素，集合不会有变化print(my_set) # 输出: {1, 2, 3, 4}# 删除元素：# remove() 方法：如果元素不存在，会抛出 KeyError 错误my_set.remove(3)print(my_set) # 输出: {1, 2, 4}# my_set.remove(5) # 这行会报错# discard() 方法：如果元素不存在，不会报错，更安全my_set.discard(4)my_set.discard(5) # 不会报错print(my_set) # 输出: {1, 2}# pop() 方法：随机删除并返回一个元素。由于集合无序，你不知道会删除哪个# removed_item = my_set.pop()# print(f"删除了: {removed_item}, 集合变为: {my_set}")# clear() 方法：清空集合my_set.clear()print(my_set) # 输出: set()
集合间的操作（数学运算）：这才是集合真正强大的地方，尤其是在处理数据关系时。
set1 = {1, 2, 3, 4}set2 = {3, 4, 5, 6}# 并集 (Union)：包含两个集合所有不重复的元素# 运算符 | 或 union() 方法union_set = set1 | set2print(f"并集: {union_set}") # 输出: {1, 2, 3, 4, 5, 6}print(f"并集 (方法): {set1.union(set2)}")# 交集 (Intersection)：包含两个集合共有的元素# 运算符 & 或 intersection() 方法intersection_set = set1 & set2print(f"交集: {intersection_set}") # 输出: {3, 4}print(f"交集 (方法): {set1.intersection(set2)}")# 差集 (Difference)：包含在 set1 但不在 set2 的元素# 运算符 - 或 difference() 方法difference_set = set1 - set2print(f"差集 (set1 - set2): {difference_set}") # 输出: {1, 2}print(f"差集 (方法): {set1.difference(set2)}")# 对称差集 (Symmetric Difference)：包含在 set1 或 set2 中，但不同时存在的元素# 运算符 ^ 或 symmetric_difference() 方法symmetric_diff_set = set1 ^ set2print(f"对称差集: {symmetric_diff_set}") # 输出: {1, 2, 5, 6}print(f"对称差集 (方法): {set1.symmetric_difference(set2)}")
其他常用操作：
立即学习“Python免费学习笔记（深入）”；
my_set = {1, 2, 3, 4}# 检查元素是否存在print(3 in my_set) # 输出: Trueprint(5 in my_set) # 输出: False# 获取集合大小print(len(my_set)) # 输出: 4# 迭代集合 (注意：由于无序，每次迭代顺序可能不同)for item in my_set: print(item)
集合最核心的优势在于其高效的成员检测（
in
操作）和自动去重。当你的数据需要这些特性时，集合往往是比列表更好的选择。
集合与列表、元组有何不同？何时选择使用集合？
我常遇到这样的情况：从数据库里拉出一堆数据，里面可能有很多重复项，如果直接用列表处理，去重效率不高，代码也啰嗦。这时候，把数据一股脑扔进集合，再转回来，瞬间清爽。这其实就引出了集合、列表和元组三者最根本的区别，以及我们该怎么选择。
从根本上讲，它们的主要差异体现在以下几个方面：
元素唯一性 (Uniqueness):
集合 (Set): 强制要求所有元素都是唯一的。你添加重复的元素，它也不会报错，但集合里最终只会保留一个。列表 (List): 允许存在重复元素。元组 (Tuple): 同样允许存在重复元素。
元素顺序 (Order):
集合 (Set): 是无序的。这意味着你不能通过索引访问集合里的元素，也不能指望每次迭代时元素的顺序都一样。列表 (List): 是有序的。元素有固定的位置（索引），可以根据索引访问。元组 (Tuple): 同样是有序的。
可变性 (Mutability):
集合 (Set): 是可变的。你可以添加、删除元素。但集合内的元素本身必须是不可变的（hashable），比如数字、字符串、元组，但不能是列表、字典或另一个集合。列表 (List): 是可变的。你可以修改、添加、删除元素。元组 (Tuple): 是不可变的。一旦创建，就不能修改其内容（虽然如果元组里包含可变对象，那个可变对象本身可以被修改）。
索引 (Indexing):
集合 (Set): 不支持索引和切片，因为它是无序的。列表 (List): 支持索引和切片。元组 (Tuple): 支持索引和切片。
何时选择使用集合？
理解了这些差异，选择就变得清晰了：
需要快速去重时： 这是集合最常见的用途。比如，你从日志文件里提取了一堆IP地址，想知道有多少个独立的IP，把它们扔进集合里就行了。进行高效的成员检测时： 判断一个元素是否在集合中（
element in my_set
）通常比在列表或元组中快得多，因为集合内部使用了哈希表（hash table）实现。如果你需要频繁地检查某个值是否存在于一个大数据集中，集合是首选。执行数学上的集合操作时： 比如你想找出两个用户群体的共同兴趣（交集），或者找出某个用户独有的权限（差集），集合的
union()
,
intersection()
,
difference()
,
symmetric_difference()
方法就非常方便和高效。当你不需要关心元素顺序时： 如果元素的顺序对你来说不重要，那么集合的无序性不会成为问题。
简而言之，当“唯一性”和“快速查找”是你的核心需求，且“顺序”不重要时，集合就是你的最佳拍档。
集合的常见操作与进阶应用
除了那些基础的增删改查，集合在实际项目里还有很多巧妙的用法。比如，你想知道两个列表里到底有哪些是重合的，或者一个列表是不是另一个的子集，集合的这些方法就派上大用场了。
1. 子集、超集与不相交集判断：
这组操作在权限管理、数据验证等场景中特别有用。
set_a = {1, 2, 3}set_b = {1, 2, 3, 4, 5}set_c = {6, 7}# issubset()：判断一个集合是否是另一个集合的子集print(f"set_a 是 set_b 的子集吗? {set_a.issubset(set_b)}") # Trueprint(f"set_b 是 set_a 的子集吗? {set_b.issubset(set_a)}") # False# issuperset()：判断一个集合是否是另一个集合的超集print(f"set_b 是 set_a 的超集吗? {set_b.issuperset(set_a)}") # Trueprint(f"set_a 是 set_b 的超集吗? {set_a.issuperset(set_b)}") # False# isdisjoint()：判断两个集合是否完全没有共同元素（不相交）print(f"set_a 和 set_c 不相交吗? {set_a.isdisjoint(set_c)}") # Trueprint(f"set_a 和 set_b 不相交吗? {set_a.isdisjoint(set_b)}") # False
2. frozenset（不可变集合）：
Python 提供了一种特殊的集合类型
frozenset
，它是不可变的。这意味着一旦创建，你就不能添加或删除元素。这有什么用呢？最主要的应用场景是：
作为字典的键： 字典的键必须是不可变的（hashable），普通集合是可变的，所以不能作为字典键。但
frozenset
可以。作为其他集合的元素： 普通集合的元素也必须是不可变的，所以你不能在一个集合里嵌套另一个普通集合。但你可以嵌套
frozenset
。
fs = frozenset([1, 2, 3])print(fs) # 输出: frozenset({1, 2, 3})# fs.add(4) # 这行会报错: AttributeError: 'frozenset' object has no attribute 'add'# 将 frozenset 作为字典的键my_dict = {frozenset({'apple', 'banana'}): '水果组合', frozenset({'carrot', 'potato'}): '蔬菜组合'}print(my_dict[frozenset({'apple', 'banana'})]) # 输出: 水果组合# 将 frozenset 作为另一个集合的元素nested_set = {1, frozenset({2, 3}), 4}print(nested_set) # 输出: {1, 4, frozenset({2, 3})} (顺序可能不同)
3. 实际应用场景示例：
数据去重： 这是最基础也是最常用的。
data_with_duplicates = [1, 5, 2, 1, 3, 5, 4, 2]unique_data = list(set(data_with_duplicates))print(f"去重后的数据: {unique_data}") # 输出: [1, 2, 3, 4, 5] (顺序可能不同)
查找共同元素： 比如找出两个班级都选了哪些课。
class_a_courses = {'Math', 'Physics', 'Chemistry', 'English'}class_b_courses = {'Biology', 'Chemistry', 'History', 'Math'}common_courses = class_a_courses.intersection(class_b_courses)print(f"两个班级都选的课程: {common_courses}") # 输出: {'Math', 'Chemistry'}
查找独有元素： 找出某个班级独选的课。
only_class_a = class_a_courses.difference(class_b_courses)print(f"A班独选的课程: {only_class_a}") # 输出: {'Physics', 'English'}
权限或标签匹配： 检查用户是否拥有所有必需的权限。
user_permissions = {'read', 'write', 'delete', 'admin'}required_permissions = {'read', 'write'}critical_permissions = {'admin', 'audit'}# 用户是否拥有所有必需权限if required_permissions.issubset(user_permissions): print("用户拥有所有必需权限。")# 用户是否拥有任何关键权限if not critical_permissions.isdisjoint(user_permissions): print("警告：用户拥有关键权限！")
集合的这些进阶用法，让它不仅仅是一个简单的去重工具，更是一个在数据分析、权限管理、关系判断等领域都极其高效的数据结构。
处理集合的注意事项与潜在陷阱
虽然集合用起来很爽，但也有几个小坑需要注意，不然很容易踩雷。理解这些细节能让你更稳健地使用集合。
1. 集合元素必须是不可变的（Hashable）：
这是集合最核心的限制之一。集合内部为了实现快速查找和去重，使用了哈希表（hash table）的原理。这意味着集合里的每个元素都必须是“可哈希的”（hashable）。简单来说，一个对象如果它的哈希值（hash value）在其生命周期内是固定的，并且可以与其他对象进行比较，那么它就是可哈希的。
可哈希的类型： 数字（int, float）、字符串（str）、元组（tuple）、frozenset。不可哈希的类型： 列表（list）、字典（dict）、普通集合（set）。因为它们是可变的，它们的哈希值可能随时改变，这会破坏哈希表的结构。
如果你尝试将不可哈希的对象添加到集合中，Python 会抛出
TypeError
。
my_set = {1, 2, "hello"}# my_set.add([3, 4]) # 这行会报错: TypeError: unhashable type: 'list'# my_set.add({'a': 1}) # 这行会报错: TypeError: unhashable type: 'dict'# my_set.add({5, 6}) # 这行会报错: TypeError: unhashable type: 'set'# 但是可以添加元组my_set.add((3, 4))print(my_set) # 输出: {1, 2, 'hello', (3, 4)} (顺序可能不同)
所以，当你需要集合中包含“集合”这类结构时，记得使用
frozenset
。
2. 创建空集合的陷阱：
{}
与
set()
：
这是初学者常犯的一个小错误。
{}
：当你写
{}
时，Python 默认创建的是一个空字典，而不是空集合。
set()
：要创建一个空集合，你必须使用
set()
构造函数。
empty_dict = {}empty_set = set()print(type(empty_dict)) # 输出: print(type(empty_set)) # 输出:
这个细节在代码中可能导致意想不到的行为，尤其是在后续操作中。
3. 集合是无序的，不要依赖元素顺序：
虽然这在前面已经提过，但它太重要了，值得再次强调。集合不会保留元素的插入顺序，每次你打印集合或迭代它时，元素的顺序都可能不同。
my_set = {1, 2, 3, 4, 5}print(my_set) # 第一次运行可能输出 {1, 2, 3, 4, 5}print(my_set) # 第二次运行可能输出 {5, 1, 2, 3, 4} (取决于Python版本和内部哈希实现)# 如果你需要有序且去重的数据，通常的做法是先用集合去重，再转换回列表并排序data = [3, 1, 4, 1, 5, 9, 2, 6]sorted_unique_data = sorted(list(set(data)))print(f"有序去重数据: {sorted_unique_data}") # 输出: [1, 2, 3, 4, 5, 6, 9]
如果你在代码中假设集合会保持某种顺序，那么你的程序很可能会在某些时候出现难以调试的错误。
以上就是Python中集合怎么使用 Python中集合使用教程的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1368905.html
微信扫一扫 
支付宝扫一扫 
