Python之集合set

我的图片 · 在线免费的图片处理工具

前言

简记录一下Python中的set集合,这里介绍一下相关基础知识,记录于此,方便自己查阅。

正文

set

集合set是:“一个无序的、元素互不相同的可哈希对象集合。”

set是可哈希:set 里的“元素”必须可哈希

set自身不可哈希:set 这个“容器对象本身”不能被哈希

特征
特征说明对比列表 list
无序不记录元素位置,也不记录插入顺序list 有顺序
不重复相同元素只能存在一个list 允许重复
元素必须可哈希只能放不可变对象(数字、字符串、元组等)list 什么都能放
可变的(set)创建后可以增删元素tuple 不可变

可哈希(hashable) 对象创建后就不能再改变,可以算出固定不变的“哈希值”,,比如int、float、str、tuple 都是可哈希的;list、dict、set自身是可变的,因此不可以可哈希。

# 集合会自动去掉重复元素
fruits = {"苹果", "香蕉", "苹果", "橘子", "香蕉"}
print(fruits)          # 输出:{'苹果', '橘子', '香蕉'}(顺序可能不同,重复项没了)
print(type(fruits))    # <class 'set'>

创建集合

使用花括号 {}
s1 = {1, 2, 3, 4}
s2 = {"猫", "狗", "兔"}
使用 set() 构造函数
s3 = set()                    # 空集合(注意:不是 {}!)
s4 = set([1, 2, 2, 3, 3, 3])  # 从列表创建,自动去重 → {1, 2, 3}
s5 = set("hello")             # 从字符串创建 → {'h', 'e', 'l', 'o'}(l 只保留一个)
s6 = set((1, 2, 3))           # 从元组创建
集合推导式
# 语法和列表推导式类似,只是把 [] 换成 {}
squares = {x * x for x in range(6)}
print(squares)   # 例如:{0, 1, 4, 9, 16, 25}
空集合只能用 set()
a = {}          # 这是 空字典 dict,不是集合!
b = set()       # 这才是 空集合 set
print(type(a))  # <class 'dict'>
print(type(b))  # <class 'set'>

{} 在 Python里已经被字典先用了,所以创建空集合必须用 set()

场见使用

成员判断
skills = {"Python", "SQL", "Excel"}
print("Python" in skills)     # True
print("Java" not in skills)   # True

列表判断成员是逐个比对的(慢),集合判断是“直接算位置”(快)。成员检测的平均时间复杂度是 O(1),数据量越大,优势越明显。

获取长度
print(len(skills))   # 3
遍历集合
for skill in skills:
    print(skill)
# 注意:输出的顺序是不确定的,每次运行可能不同

集合不支持索引和切片!

s = {1, 2, 3}
# print(s[0])      # TypeError: 'set' object is not subscriptable
# print(s[1:3])    # 同样报错

因为集合无序,所以没有“第几个元素”的概念,自然不能索引或切片。

增删改
方法作用元素不存在时
add(elem)添加一个元素无异常,直接加入
update(*iterables)批量添加(可传多个可迭代对象)—
remove(elem)删除一个元素抛出 KeyError
discard(elem)删除一个元素不报错(推荐)
pop()随机删除并返回一个元素集合为空时抛 KeyError
clear()清空所有元素—
copy()浅拷贝一个新集合—
s = {1, 2, 3}
​
s.add(4)            # {1, 2, 3, 4}
s.update([5, 6], {7, 8})  # 批量添加 → {1, 2, 3, 4, 5, 6, 7, 8}
​
s.remove(3)         # {1, 2, 4, 5, 6, 7, 8}
# s.remove(99)      # KeyError: 99(元素不存在会报错)
​
s.discard(99)       # 不会报错,安静地什么都不做(推荐日常用这个)
​
x = s.pop()         # 随机弹出一个元素,你不知道是哪个
print(x, s)
​
s.clear()           # set()
remove vs discard 怎么选?

确定元素一定存在 → 用 remove

不确定元素是否存在 → 用 discard(不会崩)

大多数场景推荐 discard,更安全。

数学运算

笔记常见,也是笔记特殊的。

每种运算都有运算符写法和方法写法两种方式。

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
交集(Intersection)—— 两个集合的共同元素
print(a & b)               # {4, 5}
print(a.intersection(b))   # {4, 5}
并集(Union)—— 两个集合的所有元素(自动去重)
print(a | b)          # {1, 2, 3, 4, 5, 6, 7, 8}
print(a.union(b))     # 同上
差集(Difference)—— 在 a 中但不在 b 中的元素
print(a - b)             # {1, 2, 3}(a 有 b 没有的)
print(b - a)             # {6, 7, 8}(b 有 a 没有的,注意方向!)
print(a.difference(b))   # {1, 2, 3}

差集有方向性**:a - b ≠ b - a,这和交集、并集不同。

对称差集(Symmetric Difference)—— 只在一个集合里出现的元素
print(a ^ b)                       # {1, 2, 3, 6, 7, 8}
print(a.symmetric_difference(b))   # 同上
# 等价于 (a - b) | (b - a)
关系判断
c = {1, 2}
print(c.issubset(a))      # True  —— c 是 a 的子集
print(a.issuperset(c))    # True  —— a 是 c 的超集
print(a.isdisjoint(b))    # False —— a 和 b 有交集(不相交才返回 True)
print(c <= a)             # True  —— 子集
print(c < a)              # True  —— 真子集(c 是 a 的子集且不相等)
print(a >= c)             # True  —— 超集
速查表
运算运算符方法含义
交集&.intersection()取共同元素
并集|.union()合并去重
差集-.difference()前者有、后者没有
对称差集^.symmetric_difference()只在一方出现的
子集<=.issubset()是否全部包含
超集>=.issuperset()是否全部被包含
不相交—.isdisjoint()交集是否为空
运算符

上面的运算都会返回新集合,不改变原来的集合。如果想直接修改原集合,用带等号的版本:

s = {1, 2, 3}
s |= {3, 4, 5}      # 等同于 s.update({3,4,5}),s 变成 {1,2,3,4,5}
s &= {2, 3, 4}      # 等同于 s.intersection_update(...),s 变成 {2,3,4}
s -= {2}            # 等同于 s.difference_update(...),s 变成 {3,4}
s ^= {4, 5, 6}      # 等同于 s.symmetric_difference_update(...),s 变成 {3,5,6}
原地运算符等价方法
s |= others.update(other)
s &= others.intersection_update(other)
s -= others.difference_update(other)
s ^= others.symmetric_difference_update(other)
方法 vs 运算符

运算符版本(&、|、-、^)要求两边都是集合,而方法版本(.union() 等)可以接受任意可迭代对象(列表、字符串、元组等)。

s = {1, 2, 3}
​
# 方法版本:可以传列表,没问题
print(s.union([3, 4, 5]))        # {1, 2, 3, 4, 5}
​
# 运算符版本:必须两边都是 set,否则报错
# print(s | [3, 4, 5])          # TypeError: unsupported operand type(s)
print(s | {3, 4, 5})            # ✅ 正确写法

frozenset

frozenset不可变的集合,前面说的都是可变的 set。Python 还提供了不可变版本 frozenset:

对比setfrozenset
可变✅ 可以增删❌ 创建后不可修改
可哈希❌✅
能当字典的 key❌✅
能作为集合的元素❌✅
有 add/remove 等方法✅❌
fs = frozenset([1, 2, 3, 1])
print(fs)           # frozenset({1, 2, 3})
# fs.add(4)         # AttributeError: 'frozenset' object has no attribute 'add'
​
# frozenset 可以作为字典的 key
d = {frozenset({1, 2}): "一组", frozenset({3, 4}): "二组"}
print(d[frozenset({1, 2})])   # 一组
​
# frozenset 可以作为集合的元素(实现"集合的集合")
nested = {frozenset({1, 2}), frozenset({3, 4})}
print(nested)   # {frozenset({1, 2}), frozenset({3, 4})}

当 set 和 frozenset 混合运算时,结果的类型和第一个操作数一致。

print(frozenset({1, 2}) | {2, 3})  # frozenset({1, 2, 3})  —— 结果是 frozenset
print({1, 2} | frozenset({2, 3}))  # {1, 2, 3}              —— 结果是 set

小结

set 是 Python 里一个无序、去重、元素可哈希的容器,最擅长三件事——去重、快速判断成员、集合运算;空集合用 set();方法版运算比运算符版更宽容(接受任意可迭代对象);需要不可变集合时用 frozenset。掌握了这些,你就已经把 set 用到了 90% 的实际场景里。

经典场景

场景 1:快速去重
names = ["小明", "小红", "小明", "小刚", "小红"]
unique_names = list(set(names))      # 先转集合去重,再转回列表
print(unique_names)                  # 顺序不确定,例如 ['小刚', '小明', '小红']
​
# 如果需要保持原来的顺序(Python 3.7+ 字典有序,可用 dict.fromkeys)
unique_ordered = list(dict.fromkeys(names))
print(unique_ordered)   # ['小明', '小红', '小刚']  ✅ 顺序保留
场景 2:快速判断元素是否存在
# 假设有 100 万个合法用户 ID
valid_ids = set(range(1_000_000))
print(999_999 in valid_ids)   # True,瞬间完成,比列表快很多
场景 3:找出两个列表的共同元素(交集)
# 用户 A 和用户 B 共同关注的博主
a_follows = {"博主1", "博主2", "博主3", "博主4"}
b_follows = {"博主3", "博主4", "博主5", "博主6"}
common = a_follows & b_follows
print(common)   # {'博主3', '博主4'}
场景 4:找出只在一个列表中出现的元素(对称差集)
# 对比两个版本的文件列表,找出哪些文件只在其中一个版本里
v1_files = {"a.py", "b.py", "c.py"}
v2_files = {"b.py", "c.py", "d.py"}
changed = v1_files ^ v2_files
print(changed)   # {'a.py', 'd.py'}

常见坑点

  1. 集合没有顺序,pop() 弹出的是“任意元素”

s = {1, 2, 3}
print(s.pop())   # 可能是 1、2 或 3,你无法确定
  1. 集合不能排序,也不能比较大小

# 集合只支持 ==、!= 以及子集/超集比较(<=、>=、<、>)
# 不支持 >、< 这种“按大小排序”的比较
a, b = {1, 2}, {2, 3}
# a < b    # False(因为它们不是子集关系)
# sorted(a, b)  # 对集合列表排序结果是未定义的
  1. 空集合判断用 if s:

s = set()
if not s:
    print("集合是空的")   # 会执行
  1. 集合的元素是“去重”的,但去重的依据是可哈希性

# 1 和 1.0 被认为是同一个元素(因为它们的哈希值相同)
s = {1, 1.0, 2}
print(s)   # {1, 2}(1 和 1.0 被视为相等,只保留一个)

参考文章

  1. AI

  2. Python文档

暂无评论

none
暂无评论...