Python 集合（Set）使用指南：从创建到性能实践

set() 可以把任何可迭代对象（如字符串、列表）转成集合，重复元素自动消失。生成式语法（comprehension）也适用。

遍历集合

因为没有索引，只能用 for 循环遍历，而且每次输出的顺序可能不同 —— 这正是无序性的体现。

set1 = {'Python', 'C++', 'Java', 'Kotlin', 'Swift'}
for elem in set1:
    print(elem)

运行一下上面的代码，观察单词的出现顺序，体会无序性。

len() 可以获得集合的元素个数。

集合运算

成员运算

直接用 in 和 not in：

set1 = {11, 12, 13, 14, 15}
print(10 in set1)      # False 
print(15 in set1)      # True
set2 = {'Python', 'Java', 'C++', 'Swift'}
print('Ruby' in set2)  # False
print('Java' in set2)  # True

交集、并集、差集、对称差

运算符 & | - ^ 和对应的方法 intersection, union, difference, symmetric_difference 都可以用。运算符通常更直观。

set1 = {1, 2, 3, 4, 5, 6, 7}
set2 = {2, 4, 6, 8, 10}

# 交集
print(set1 & set2)                      # {2, 4, 6}
print(set1.intersection(set2))          # {2, 4, 6}

# 并集
print(set1 | set2)                      # {1, 2, 3, 4, 5, 6, 7, 8, 10}
print(set1.union(set2))                 # {1, 2, 3, 4, 5, 6, 7, 8, 10}

# 差集
print(set1 - set2)                      # {1, 3, 5, 7}
print(set1.difference(set2))            # {1, 3, 5, 7}

# 对称差
print(set1 ^ set2)                      # {1, 3, 5, 7, 8, 10}
print(set1.symmetric_difference(set2))  # {1, 3, 5, 7, 8, 10}

还有复合赋值运算符：|=, &=, -=, ^=，对应方法 update, intersection_update, difference_update, symmetric_difference_update。

set1 = {1, 3, 5, 7}
set2 = {2, 4, 6}
set1 |= set2          # 相当于 set1.update(set2)
print(set1)           # {1, 2, 3, 4, 5, 6, 7}
set3 = {3, 6, 9}
set1 &= set3          # 相当于 set1.intersection_update(set3)
print(set1)           # {3, 6}
set2 -= set1          # 相当于 set2.difference_update(set1)
print(set2)           # {2, 4}

比较运算

用 ==, != 判断相等，<, <=, >, >= 判断子集 / 超集关系。或使用 issubset, issuperset 方法。

set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 = {5, 4, 3, 2, 1}

print(set1 < set2)   # True
print(set1 <= set2)  # True
print(set2 < set3)   # False
print(set2 <= set3)  # True
print(set2 > set1)   # True
print(set2 == set3)  # True

print(set1.issubset(set2))    # True
print(set2.issuperset(set1))  # True

set1 < set2 表示 set1 是 set2 的真子集，set1 <= set2 只要求是子集。

修改集合

集合是可变的，可以添加、删除元素。

set1 = {1, 10, 100}

set1.add(1000)
set1.add(10000)
print(set1)  # {1, 10, 100, 1000, 10000}

# discard 即使元素不存在也不会报错
set1.discard(10)
# remove 在元素不存在时会抛出 KeyError，所以要小心
if 100 in set1:
    set1.remove(100)
print(set1)  # {1, 1000, 10000}

# 清空
set1.clear()
print(set1)  # set()

pop() 会随机删除并返回一个元素（因为无序），而 remove 和 discard 只删除不返回。

判断是否无交集

isdisjoint() 在两个集合没有共同元素时返回 True：

set1 = {'Java', 'Python', 'C++', 'Kotlin'}
set2 = {'Kotlin', 'Swift', 'Java', 'Dart'}
set3 = {'HTML', 'CSS', 'JavaScript'}
print(set1.isdisjoint(set2))  # False
print(set1.isdisjoint(set3))  # True

不可变集合 frozenset

frozenset 是不可变版本，一旦创建就不能增删元素。但它可哈希，所以可以作为 set 的元素（或者字典的键）。除了不能修改，其他运算和 set 完全一样。

fset1 = frozenset({1, 3, 5, 7})
fset2 = frozenset(range(1, 6))
print(fset1)          # frozenset({1, 3, 5, 7})
print(fset2)          # frozenset({1, 2, 3, 4, 5})
print(fset1 & fset2)  # frozenset({1, 3, 5})
print(fset1 | fset2)  # frozenset({1, 2, 3, 4, 5, 7})
print(fset1 - fset2)  # frozenset({7})
print(fset1 < fset2)  # False

性能考量与实用技巧

什么时候用集合

1. 去重：把列表转集合再转回来，但顺序会乱。如果还需要原来的顺序，可以借助 dict（Python 3.7+ 有序）或 OrderedDict。

   # 直接去重，顺序不保证
   unique = list(set(['apple', 'banana', 'apple', 'orange']))
   # 保持顺序的去重
   from collections import OrderedDict
   ordered_unique = list(OrderedDict.fromkeys(['apple', 'banana', 'apple', 'orange']))
   

2. 高效成员检查：循环里反复出现 if x in ... 时，如果数据量大，把列表换成集合通常能得到数量级的性能提升。

3. 集合运算：交集、并集、差集这种数学操作，用运算符写出来非常简洁，比循环嵌套快得多。

要注意的坑

• 元素必须可哈希：往集合里放列表或字典会直接抛出 TypeError。
• 线程安全：集合本身不是线程安全的，多线程并发修改需要加锁或使用 queue.Queue 等专用结构。
• 空集合陷阱：{} 是字典，一定要用 set() 创建空集合。

总之，集合适合处理'有没有'、'哪些是共同'、'哪些是独有的'这类问题，但如果你需要顺序、索引或嵌套可变结构，就该回到列表或其他容器。