Python创建集合的三种方法解析

本文详细介绍了Python中创建集合的两种主要方法：使用花括号`{}`和`set()`构造函数。重点强调了使用`{}`创建空集合时会生成字典而非集合的常见错误，并推荐使用`set()`来创建空集合。文章还深入探讨了集合的核心特性，如唯一性、无序性和元素不可变性，以及集合在数据去重、成员检测和集合运算等方面的应用。此外，还详细讲解了集合的常用操作，包括添加、删除元素以及并集、交集、差集等数学集合运算。最后，文章对比了集合与列表、元组的选择场景，强调了在需要元素唯一性和高效查找时，集合的优势。通过本文，读者可以全面掌握Python集合的创建、特性、操作和应用，从而在实际开发中选择合适的数据结构，提升代码效率。

创建集合推荐使用set()构造函数，因{}会创建字典；集合具唯一性、无序性、元素需不可变，适用于去重、成员检测及集合运算。

在Python中，创建一个集合（set）主要有两种方式：使用花括号 {} 直接定义，或者通过 set() 构造函数。这两种方法各有侧重，理解它们的区别是高效使用集合的关键。

解决方案

要创建一个Python集合，最直观的方式是使用花括号 {}，并将元素用逗号分隔。但这里有个小陷阱，如果你想创建一个空集合，{} 实际上会创建一个空字典，而不是空集合。正确的空集合创建方式是使用 set() 构造函数。

举个例子：

# 方法一：使用花括号 {} 创建非空集合
my_set = {1, 2, 3, 'apple', 'banana'}
print(f"通过花括号创建的集合: {my_set}")
print(f"类型: {type(my_set)}")

# 错误示范：创建一个空字典，而非空集合
empty_dict = {}
print(f"通过花括号创建的空集合（实际是字典）: {empty_dict}")
print(f"类型: {type(empty_dict)}")

# 方法二：使用 set() 构造函数创建集合
# 创建空集合
empty_set = set()
print(f"通过 set() 创建的空集合: {empty_set}")
print(f"类型: {type(empty_set)}")

# 从列表创建集合（会自动去重）
list_data = [1, 2, 2, 3, 'apple', 'apple', 'orange']
set_from_list = set(list_data)
print(f"从列表创建的集合: {set_from_list}")

# 从元组创建集合
tuple_data = (10, 20, 20, 30)
set_from_tuple = set(tuple_data)
print(f"从元组创建的集合: {set_from_tuple}")

# 从字符串创建集合（会把每个字符作为一个元素，并去重）
string_data = "hello"
set_from_string = set(string_data)
print(f"从字符串创建的集合: {set_from_string}") # 结果可能是 {'o', 'l', 'e', 'h'}，顺序不确定

可以看到，set() 构造函数非常灵活，可以接受任何可迭代对象（如列表、元组、字符串、range对象等）作为参数，并将其中的元素转换为集合的元素。这个过程中，它会自动处理重复项，确保集合中每个元素都是唯一的。

Python集合有哪些核心特性和应用场景？

集合（set）在Python中是一个非常独特的数据结构，它不像列表或元组那样简单。我个人觉得，理解它的核心特性，是掌握它强大之处的关键。

首先，也是最重要的一个特性，就是元素唯一性。集合会自动排除重复的元素。当你需要处理一个数据集，并且只关心其中不重复的值时，集合简直是“神器”。比如，我以前在处理用户ID日志时，经常会遇到大量重复的ID，如果想快速统计有多少独立用户，把所有ID扔进一个集合，瞬间就能得到结果，效率比循环判断快得多。

其次，集合是无序的。这意味着你不能通过索引来访问集合中的元素，比如 my_set[0] 这种操作是不被允许的。集合内部的存储方式决定了它不关心元素的排列顺序，这有时会让初学者感到困惑，但正是这种无序性，使得集合在查找、插入和删除操作上表现出惊人的效率（通常是O(1)的平均时间复杂度）。

再者，集合中的元素必须是不可变对象。你可以把数字、字符串、元组放进集合，但不能直接把列表、字典或另一个集合放进去，因为它们是可变的。如果你尝试这样做，Python会报错。这个限制其实是为了保证集合内部哈希（hash）机制的正常运作，确保元素的唯一性和快速查找。当然，如果你非要存一个可变对象，可以考虑将可变对象转换为不可变形式（比如将列表转换为元组），但这通常意味着你可能需要重新审视你的数据结构设计。

至于应用场景，那真是五花八门：

• 去重：这是最常见的用途，无论数据来自文件、数据库还是网络，集合都能高效完成。
• 成员资格测试：判断一个元素是否在集合中，速度极快。比如，检查一个单词是否在某个词汇表中，比遍历列表要快得多。
• 数学集合操作：并集、交集、差集、对称差集，这些在数据分析和算法中非常有用。比如，找出两个用户群体的共同偏好（交集），或者找出某个群体独有的特征（差集）。
• 消除冗余数据：在处理配置项、权限列表等场景时，集合能确保每个项都是唯一的。

我曾经用集合来优化一个推荐系统的数据预处理环节，通过集合的快速去重和交集操作，显著提升了数据清洗的效率，这比我最初用循环和条件判断要简洁和高效得多。

除了创建，我们还能对Python集合进行哪些常用操作？

创建集合只是第一步，真正让集合发挥作用的是它提供的各种操作方法。这些方法让我们可以方便地处理集合间的关系，以及对集合内部元素进行增删改查。

# 示例集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = {1, 2}

print(f"原始集合1: {set1}")
print(f"原始集合2: {set2}")
print(f"原始集合3: {set3}\n")

# 1. 添加元素
# add() 方法用于添加单个元素
set1.add(6)
set1.add(1) # 添加已存在的元素不会有任何效果
print(f"添加元素后的集合1: {set1}") # 结果是 {1, 2, 3, 4, 5, 6}

# update() 方法用于添加多个元素（可以是列表、元组、另一个集合等）
set1.update([7, 8], {9, 10})
print(f"更新元素后的集合1: {set1}\n") # 结果是 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

# 2. 删除元素
# remove() 方法：删除指定元素，如果元素不存在会报错 KeyError
try:
    set1.remove(10)
    print(f"删除元素10后的集合1: {set1}")
    # set1.remove(100) # 尝试删除不存在的元素会报错
except KeyError:
    print("尝试删除不存在的元素引发了 KeyError\n")

# discard() 方法：删除指定元素，如果元素不存在不会报错
set1.discard(9)
set1.discard(100) # 删除不存在的元素不会报错
print(f"删除元素9后的集合1: {set1}")

# pop() 方法：随机删除并返回一个元素，空集合调用会报错 KeyError
try:
    popped_element = set1.pop()
    print(f"弹出的元素: {popped_element}, 剩余集合1: {set1}")
except KeyError:
    print("尝试从空集合弹出元素引发了 KeyError\n")

# clear() 方法：清空集合
temp_set = {1, 2, 3}
temp_set.clear()
print(f"清空后的集合: {temp_set}\n")

# 3. 集合运算（数学集合操作）
# 并集 (Union)：union() 方法或 | 运算符
union_set = set1.union(set2)
# union_set = set1 | set2
print(f"集合1和集合2的并集: {union_set}")

# 交集 (Intersection)：intersection() 方法或 & 运算符
intersection_set = set1.intersection(set2)
# intersection_set = set1 & set2
print(f"集合1和集合2的交集: {intersection_set}")

# 差集 (Difference)：difference() 方法或 - 运算符
difference_set = set1.difference(set2) # 集合1中有但集合2中没有的元素
# difference_set = set1 - set2
print(f"集合1和集合2的差集 (set1 - set2): {difference_set}")

# 对称差集 (Symmetric Difference)：symmetric_difference() 方法或 ^ 运算符
symmetric_difference_set = set1.symmetric_difference(set2) # 两个集合中独有的元素
# symmetric_difference_set = set1 ^ set2
print(f"集合1和集合2的对称差集: {symmetric_difference_set}\n")

# 4. 子集与超集判断
# issubset() 方法：判断一个集合是否是另一个集合的子集
print(f"集合3是集合1的子集吗? {set3.issubset(set1)}") # True
print(f"集合1是集合3的子集吗? {set1.issubset(set3)}") # False

# issuperset() 方法：判断一个集合是否是另一个集合的超集
print(f"集合1是集合3的超集吗? {set1.issuperset(set3)}") # True
print(f"集合3是集合1的超集吗? {set3.issuperset(set1)}") # False

# isdisjoint() 方法：判断两个集合是否没有共同元素（不相交）
disjoint_set = {100, 200}
print(f"集合1和 {disjoint_set} 不相交吗? {set1.isdisjoint(disjoint_set)}") # True
print(f"集合1和集合2不相交吗? {set1.isdisjoint(set2)}") # False

这些操作，尤其是集合运算，在处理数据关系时非常强大。比如，我曾经需要找出两个用户组中既不重叠，又不是完全包含关系的用户，对称差集就完美解决了这个问题。使用这些内置方法，代码不仅更简洁，而且通常比手动循环判断要高效得多。

在实际开发中，什么时候选择使用集合（set）而不是列表或元组？

这是一个很实际的问题，也是我经常在代码审查时会关注的地方。选择合适的数据结构，能让你的代码更高效、更易读。

最核心的考量点，我觉得在于你对元素唯一性和查找效率的需求。

如果你需要一个容器来存储一系列元素，并且：

1. 不关心元素的顺序。
2. 确保所有元素都是唯一的。
3. 需要频繁地检查某个元素是否存在（成员资格测试）。
4. 需要进行数学上的集合运算（并集、交集、差集等）。

那么，集合（set）就是你的首选。它的内部实现（哈希表）使得成员资格测试的平均时间复杂度是 O(1)，这意味着无论集合有多大，查找一个元素的速度都非常快。这与列表（list）的 O(n) 查找速度形成了鲜明对比，当列表非常大时，查找效率会显著下降。

举个例子： 假设你正在开发一个用户权限管理系统，每个用户可能有多个角色，每个角色又包含多个权限。你需要快速判断一个用户是否拥有某个特定权限。

• 如果你用列表来存储权限，每次判断都需要遍历列表，效率低下。
• 但如果将用户的权限存储在一个集合中，'admin_permission' in user_permissions_set 这样的操作几乎是瞬时的。

再比如，在数据清洗阶段，我经常会从不同的数据源获取用户ID。如果我需要统计所有不重复的用户ID，把它们全部放到一个列表中，然后手动去重（比如用循环加条件判断），那会非常慢且容易出错。但如果直接扔进一个集合，重复的ID会自动被忽略，最终集合里就是所有不重复的ID。

相比之下：

• 列表（list）：当你需要一个有序的元素序列，且元素可以重复，并且经常需要通过索引访问元素时，列表是最佳选择。
• 元组（tuple）：当你需要一个有序且不可变的元素序列时，元组是理想选择。它通常用于表示固定大小、不可更改的数据集，例如坐标点 (x, y)。

所以，选择哪种数据结构，真的取决于你的具体需求。没有绝对的好坏，只有是否适合当前场景。在我的经验里，很多人习惯性地用列表，但在很多需要去重或快速查找的场景，切换到集合会带来意想不到的性能提升和代码简化。这种思维上的转变，往往是写出更优雅、更高效Python代码的关键一步。

今天关于《Python创建集合的三种方法解析》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！