Python集合使用教程详解

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Python集合怎么用？集合基础教程详解》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

集合是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 | set2
print(f"并集: {union_set}") # 输出: {1, 2, 3, 4, 5, 6}
print(f"并集 (方法): {set1.union(set2)}")

# 交集 (Intersection)：包含两个集合共有的元素
# 运算符 & 或 intersection() 方法
intersection_set = set1 & set2
print(f"交集: {intersection_set}") # 输出: {3, 4}
print(f"交集 (方法): {set1.intersection(set2)}")

# 差集 (Difference)：包含在 set1 但不在 set2 的元素
# 运算符 - 或 difference() 方法
difference_set = set1 - set2
print(f"差集 (set1 - set2): {difference_set}") # 输出: {1, 2}
print(f"差集 (方法): {set1.difference(set2)}")

# 对称差集 (Symmetric Difference)：包含在 set1 或 set2 中，但不同时存在的元素
# 运算符 ^ 或 symmetric_difference() 方法
symmetric_diff_set = set1 ^ set2
print(f"对称差集: {symmetric_diff_set}") # 输出: {1, 2, 5, 6}
print(f"对称差集 (方法): {set1.symmetric_difference(set2)}")

其他常用操作：

my_set = {1, 2, 3, 4}

# 检查元素是否存在
print(3 in my_set) # 输出: True
print(5 in my_set) # 输出: False

# 获取集合大小
print(len(my_set)) # 输出: 4

# 迭代集合 (注意：由于无序，每次迭代顺序可能不同)
for item in my_set:
    print(item)

集合最核心的优势在于其高效的成员检测（in 操作）和自动去重。当你的数据需要这些特性时，集合往往是比列表更好的选择。

集合与列表、元组有何不同？何时选择使用集合？

我常遇到这样的情况：从数据库里拉出一堆数据，里面可能有很多重复项，如果直接用列表处理，去重效率不高，代码也啰嗦。这时候，把数据一股脑扔进集合，再转回来，瞬间清爽。这其实就引出了集合、列表和元组三者最根本的区别，以及我们该怎么选择。

从根本上讲，它们的主要差异体现在以下几个方面：

1. 元素唯一性 (Uniqueness):

   • 集合 (Set): 强制要求所有元素都是唯一的。你添加重复的元素，它也不会报错，但集合里最终只会保留一个。
   • 列表 (List): 允许存在重复元素。
   • 元组 (Tuple): 同样允许存在重复元素。

2. 元素顺序 (Order):

   • 集合 (Set): 是无序的。这意味着你不能通过索引访问集合里的元素，也不能指望每次迭代时元素的顺序都一样。
   • 列表 (List): 是有序的。元素有固定的位置（索引），可以根据索引访问。
   • 元组 (Tuple): 同样是有序的。

3. 可变性 (Mutability):

   • 集合 (Set): 是可变的。你可以添加、删除元素。但集合内的元素本身必须是不可变的（hashable），比如数字、字符串、元组，但不能是列表、字典或另一个集合。
   • 列表 (List): 是可变的。你可以修改、添加、删除元素。
   • 元组 (Tuple): 是不可变的。一旦创建，就不能修改其内容（虽然如果元组里包含可变对象，那个可变对象本身可以被修改）。

4. 索引 (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)}") # True
print(f"set_b 是 set_a 的子集吗? {set_b.issubset(set_a)}") # False

# issuperset()：判断一个集合是否是另一个集合的超集
print(f"set_b 是 set_a 的超集吗? {set_b.issuperset(set_a)}") # True
print(f"set_a 是 set_b 的超集吗? {set_a.issuperset(set_b)}") # False

# isdisjoint()：判断两个集合是否完全没有共同元素（不相交）
print(f"set_a 和 set_c 不相交吗? {set_a.isdisjoint(set_c)}") # True
print(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]

如果你在代码中假设集合会保持某种顺序，那么你的程序很可能会在某些时候出现难以调试的错误。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。