集合

是什么，为什么存在

Python 集合是一组互不相等的 可哈希元素（hashable element） 。set 可以修改，frozenset 不能修改；两者都不支持按位置索引，也不承诺迭代顺序。集合字面量会自动合并重复项，但这种合并只保留成员关系，不保留原始位置或出现次数。

集合解决的是「某个值是否属于这一组」以及「两组成员如何组合」的问题。权限名、功能开关、已访问节点和两份配置的键，通常都天然是集合。订单序列、事件日志或排行榜则不是，因为这些数据的顺序和重复次数本身有意义。

集合运算把容易写错的嵌套循环变成明确的代数。required - granted 表示缺少的权限，old & new 表示两边共有的成员，left ^ right 表示只出现在一边的成员。表达式说明了关系，也迫使你先决定结果是否应当去重。

set 与其他常见容器的边界如下。这里的「无顺序」不是说每次迭代一定变化，而是说程序不能把观察到的顺序当成契约。

工作原理

集合用元素的哈希值和相等关系组织成员。插入或查询对象时，Python 先取得哈希值，再在可能匹配的位置检查相等性。两个对象只有在比较相等并满足相同哈希约束时才代表同一个成员；哈希碰撞本身不会让不同对象被错误合并。

创建非空集合可以使用 {value1, value2}，创建空集合必须使用 set()，因为 {} 表示空字典。set(iterable) 会消费一个 可迭代对象（iterable） 并加入其中的成员。集合推导式 {transform(item) for item in source if condition(item)} 则把转换、筛选和去重放在一次构造中。

构造与复制

集合字面量会先计算各个元素表达式，再按哈希与相等规则加入成员。某个元素不可哈希时，构造立即抛出 TypeError，不会返回一个只包含前面元素的集合。推导式也可能在处理到不可哈希结果时中止。

set(source) 的输入遵循普通迭代规则，而不是为每种容器猜测业务含义。字符串会产出字符，字典会产出键，字典视图则按其视图类型产出键、值或键值对。调用者应明确传入的迭代单位是否就是集合成员。

• set(existing_set) 创建一个新的可变集合。
• frozenset(existing_frozenset) 可以返回原来的不可变对象。
• set(mapping) 收集映射的键，不收集值。
• 集合构造是浅层的，不会复制成员对象。

浅层构造意味着新旧集合的成员关系可以独立变化，但两边可能仍引用同一个成员对象。由于成员必须可哈希，内置可变容器不能直接成为这种共享成员；默认按对象标识哈希的自定义实例仍可能出现这种别名关系。

修改成员

set 的修改方法作用于原对象。任何指向该对象的别名都会观察到变化，所以选择原地方法之前要先确认所有权。

remove() 适合把「成员本应存在」当成不变量的代码，因为缺失会暴露错误。discard() 适合幂等清理，即重复执行删除仍得到相同最终状态。pop() 返回的是任意成员，不能把它当成队列或栈操作。

集合代数

四个二元运算都返回新集合，不修改左右操作数。差集有方向，对称差集没有方向。

对应的 update()、intersection_update()、difference_update() 和 symmetric_difference_update() 会原地修改接收者。|=、&=、-= 和 ^= 也表达原地修改。函数接收调用方集合时，除非契约明确允许，否则应优先返回新集合。

关系与操作数

left <= right 判断子集，left < right 判断真子集；>= 和 > 分别判断超集与真超集。left.isdisjoint(right) 在两边没有共同成员时返回 True。集合只定义部分顺序，因此 sorted() 才表示元素排序，< 并不表示字典序比较。

方法形式与运算符形式对操作数的要求不同。items.intersection(sequence) 可以接收任意可迭代对象，而 items & sequence 要求另一边也是集合类型。这一区别能让方法避免不必要的转换，也能让运算符及时暴露把列表误当集合的错误。

当 set 与 frozenset 混合进行二元运算时，结果类型跟随左操作数。mutable | frozen 得到 set，frozen | mutable 得到 frozenset。如果结果随后要作为字典键或另一个集合的成员，应让不可变集合位于左侧，或显式构造 frozenset。

set 与 frozenset 的选择

需要逐步加入、撤销或同步成员时使用 set。如果成员集合构造后不应改变，或者它本身要成为字典键或集合元素，就使用 frozenset。冻结只阻止成员集合变化，并不会递归复制或冻结成员对象。

两种类型共享非修改型运算和关系判断。把公开配置暴露为 frozenset 可以表达「调用者不能通过这个接口增删成员」，但它不能替代领域验证，也不能自动让成员指向的对象变成只读。

示例

下面四个例子从基本构造逐步走到差异计算、策略检查和不可变集合。凡是要显示集合内容，代码都会先排序，因此记录的输出不依赖本次进程采用的集合迭代顺序。

去重与成员测试

这个例子把访问记录转换成唯一客户 ID 集合。原始列表仍保留请求次数和到达顺序，集合只负责唯一成员和成员测试。

len(visits) 是六，因为列表保留重复请求；len(unique_customer_ids) 如果读取则会是四。两种容器回答不同问题，所以不要在完成计数前覆盖原始列表。

空集合使用 set()。如果写成 {}，最后一行会显示 dict，后续调用 add() 时才暴露类型错误。

计算部署差异

集合差异很适合描述期望状态与当前状态之间的迁移。方向写在变量名和表达式中，比单独保留一个对称差集更能说明下一步动作。

deployed = {"search", "billing", "profile"}
desired = {"billing", "profile", "reports"}

added = desired - deployed
removed = deployed - desired
unchanged = deployed & desired
changed = deployed ^ desired

# 计算返回新集合，两个输入保持不变。
print("added:", sorted(added))
print("removed:", sorted(removed))
print("unchanged:", sorted(unchanged))
print("changed:", sorted(changed))
print("reports ready:", {"billing", "reports"} <= desired)

added: ['reports']
removed: ['search']
unchanged: ['billing', 'profile']
changed: ['reports', 'search']
reports ready: True

desired - deployed 是要添加的服务，反向差集则是要移除的服务。changed 适合回答「哪些成员不同」，却不能单独告诉部署器应该添加还是删除。

最后的 <= 判断一组依赖是否都在期望状态中。它允许左右集合相等；如果业务要求右边还必须包含其他服务，才应使用真子集运算符 <。

检查访问策略

函数在边界处把输入转成集合，再分别计算缺失权限与冲突权限。返回值使用排序列表，让日志、测试和 API 响应保持稳定。

def evaluate_access(granted, required, blocked):
    granted_set = set(granted)
    required_set = set(required)
    blocked_set = set(blocked)

    missing = required_set - granted_set
    conflicts = granted_set & blocked_set
    return {
        "missing": sorted(missing),
        "conflicts": sorted(conflicts),
        "allowed": not missing and not conflicts,
    }


result = evaluate_access(
    ["invoice.read", "invoice.export", "account.suspend"],
    ["invoice.read", "invoice.refund"],
    ["account.suspend"],
)

print("missing:", result["missing"])
print("conflicts:", result["conflicts"])
print("allowed:", result["allowed"])

missing: ['invoice.refund']
conflicts: ['account.suspend']
allowed: False

required_set - granted_set 保留方向信息：它只列出调用方还缺什么。若改用对称差集，额外授予但并未禁止的权限也会混进结果，改变策略含义。

这个函数没有修改三个输入。即使调用方传入的本来就是集合，边界处的 set(...) 也会创建浅副本，使函数内部的后续修改不会泄漏给调用方。

用 frozenset 表示无序组合

一个无向组合没有「第一个」和「第二个」成员。frozenset 同时表达无序、唯一和不可修改，因此可以直接作为映射键。

route_owners = {
    frozenset({"billing", "exports"}): "finance-platform",
    frozenset({"search", "catalog"}): "discovery",
}

requested_route = frozenset({"exports", "billing"})
print("owner:", route_owners[requested_route])

mutable_group = {"billing"}
frozen_group = frozenset(mutable_group)
mutable_group.add("audit")

print("frozen:", sorted(frozen_group))
print("mutable:", sorted(mutable_group))
print("mixed type:", type(frozen_group | {"audit"}).__name__)
print("equivalent count:", len({True, 1, 1.0}))

owner: finance-platform
frozen: ['billing']
mutable: ['audit', 'billing']
mixed type: frozenset
equivalent count: 1

构造 frozen_group 会复制当时的成员，所以之后修改 mutable_group 不会改变它。混合运算的左操作数是 frozenset，结果也保持为 frozenset。

最后一行展示了集合依赖相等与哈希，而不是依赖类型名称。True == 1 == 1.0，这些数值也满足相等对象的哈希约束，所以集合只保留一个成员。

陷阱

用 {} 创建空集合

修复： 使用 set()，并在类型影响控制流时测试空输入。非空的 {member} 才是集合字面量；字典字面量包含冒号，例如 {"id": 1}。

把「不可变」当成「可哈希」

修复： 按可哈希协议判断：对象生命周期内哈希值必须不变，而且相等对象必须具有相同哈希值。嵌套成员集合可以使用 frozenset；结构化记录应选择明确、稳定的不可变键，而不是随意把外层换成元组。

把迭代顺序当成输出契约

修复： 可比较的元素使用 sorted(a_set) 生成稳定输出；元素不能直接比较时，提供明确的排序键。若要求保留首次出现顺序，应遍历原序列并用辅助集合记录已见键，不能先转换整个序列。

写反差集或意外原地修改

修复： 使用 added = desired - current 和 removed = current - desired 这类带方向的名称。函数接收外部集合时默认使用非原地运算；只有契约声明所有权转移或允许修改时才使用更新运算。

迭代时改变集合大小

修复： 用集合推导式构造新结果，先计算待删除集合再执行差集更新，或迭代 members.copy()。需要暴露意外缺失时保留 remove()；只有缺失本来就允许时才用 discard()。

丢失次数和相等类型

修复： 先写清楚唯一性的键和所需输出。要计数时使用 collections.Counter；要按业务键保留第一条记录时，遍历原序列并维护 seen_keys；类型必须区分时，把类型标签纳入键并测试跨类型相等值。

延伸阅读

以下链接均指向本主题验证时使用的 Python 3.14 官方文档。

• 内置类型中的 set 与 frozenset
• Python 教程中的集合
• Python 术语表中的 hashable