Python集合能存哪些数据：可变与不可变对象限制解析

在 Python 中，集合（set）只能存放具备“可哈希”（Hashable）特性的数据对象。直观的结论是：绝大多数不可变对象（如整数、浮点数、字符串、纯不可变元组、frozenset）都可以自由存入集合；而所有可变对象（如列表、字典、普通集合本身）以及内部嵌套了可变对象的元组，都绝对不能放入集合中。一旦尝试添加不可哈希对象，Python 解释器会立即抛出 TypeError: unhashable type 异常。

一、根本原因：集合为何对元素可变性设限

许多初学者容易产生一种直觉偏差，认为“集合既然是容器，理应和列表一样接纳任意类型”。但如果从集合的底层架构和定位来看，这一限制并非设计缺陷，而是维持其极高运行效率的基石。

Python 的集合底层采用哈希表（Hash Table）结构实现。与列表通过从头到尾线性扫描（时间复杂度为 \(O(n)\)）来判断元素是否存在不同，集合在添加元素或检查 x in my_set 时，能以平均 \(O(1)\) 的常数时间完成。实现这种近乎瞬间查找的关键在于哈希定位：

1. 当向集合添加对象 x 时，系统会首先调用内部的 hash(x) 计算出一个整数哈希码。
2. 通过哈希码快速映射到内存哈希表的特定存储桶（Bucket）位置。
3. 如果桶内已有数据，再通过 ==（即对象的 __eq__ 方法）校验是否内容相等，以实现去重。

这种机制要求对象必须满足一条铁律：对象的哈希值在其整个生命周期中必须保持恒定不变。如果允许列表等可变对象进入集合，假设我们将 [1, 2] 存入了桶 A，随后代码执行了 list.append(3)，该列表的内容和哈希期望发生了改变，但集合并不知道它已经变化，不会去重新调整桶位置。此时若再次查询原列表，哈希查找将直接命中错误的桶，导致“明明列表在集合里却查不到，或集合去重失效”的严重逻辑崩塌。因此，Python 从语言层面直接禁止了可变对象进入集合。

二、哪些数据可以存入集合：可哈希的不可变对象

一个对象只要实现了 __hash__() 方法，且在整个运行周期内哈希值固定，并且实现了用于对比相等的 __eq__() 方法，它就是可哈希的。Python 中的标准不可变类型默认都符合该标准。

1. 基础标量数据类型

• 整型与浮点型（int, float）：如 1, 100, 3.14。需要注意，布尔值在 Python 中是整型的子类，True == 1 且 hash(True) == hash(1)，因此集合中若已存在 1，再存入 True 会被视作重复元素而被合并。
• 布尔型（bool）：True, False。
• 复数（complex）：如 1 + 2j，不可变且完全可哈希。

# 基础标量入集合示例
s = {100, 3.14, "hello", True}
print(s)  # 示例输出: {100, 3.14, 'hello'} （True 与 1 冲突去重）

2. 序列与文本类不可变对象

• 字符串（str）：文本不可变，每个相同内容的字符串具有确定哈希值。
• 字节串（bytes）：如 b'hello'，属于不可变二进制序列，可直接放入集合。注意可变字节数组 bytearray 则不可存入。

3. 不可变容器与特殊集合

• 纯不可变元组（tuple）：只有当元组内的每一个成员自身都可哈希时，元组才可哈希（例如 (1, 2, 'ok')）。
• 不可变集合（frozenset）：如果需要把“集合”当作另一个集合的元素，必须使用 frozenset。它是 set 的只读版本，创建后不可修改，因此具备哈希能力。

# 使用 frozenset 作为集合元素
group_a = frozenset([1, 2])
group_b = frozenset([3, 4])
meta_set = {group_a, group_b}
print(meta_set)  # 示例输出: {frozenset({1, 2}), frozenset({3, 4})}

三、哪些数据禁止存入：可变对象的报错特征

如果在实际编写代码时不小心将可变容器放入集合，Python 会在执行期间立即抛出 TypeError。理解这些典型报错能够帮助我们快速定位数据清洗或算法中的逻辑错误。

1. 列表作为元素报错

# 错误示例：向集合放入列表
bad_set = {[1, 2], [3, 4]}
# 抛出异常: TypeError: unhashable type: 'list'

解决方案：如果需要存储序列，且该序列不需要修改，应在放入集合前将其显式转换为元组：tuple([1, 2])。

2. 字典作为元素报错

# 错误示例：向集合放入字典
bad_set = {{"name": "Alice"}, {"name": "Bob"}}
# 抛出异常: TypeError: unhashable type: 'dict'

解决方案：若需将字典结构存入集合去重，可将字典的键值对转为排序后的元组列表，或者使用 frozenset(d.items())。

3. 集合作为集合的元素报错（集合嵌套集合）

# 错误示例：嵌套普通集合
bad_set = {{1, 2}, {3, 4}}
# 抛出异常: TypeError: unhashable type: 'set'

因为 set 本身支持 add(), remove() 等原位修改方法，它是典型的可变类型。如果要表示“由集合构成的集合”，内层必须使用前文介绍的 frozenset。

四、深度剖析：元组“看似不可变”为何仍可能引发报错？

这是 Python 面试与日常业务代码中极其高频出现的误区：元组是不可变对象，那是否意味着任何元组都能无条件存入集合？

答案是否定的。请看以下反例：

# 表面上是元组，但内部包含一个列表
t = (1, 2, [3, 4])
s = set()
s.add(t)
# 抛出异常: TypeError: unhashable type: 'list'

报错信息清晰地指出：引发问题的并不是外层的元组，而是元组深处的 list。这是因为元组的“不可变”具有浅层性（Shallow Immutability）：元组仅保证其内部持有的对象引用（内存地址指针）不被修改，但并不约束所引用对象本身的内容是否可变。

当 Python 对元组调用 hash(t) 时，它会递归遍历该元组中的每一个元素，并将所有子元素的哈希值混合计算。当计算推进到 [3, 4] 时，列表对象由于未定义哈希方法，瞬间打断了整个元组的哈希计算，进而导致 TypeError。

五、进阶拓展：自定义类实例进入集合的控制法则

除了内置数据类型，开发者自定义编写的类（Class）对象是否能放入集合中？规则同样由哈希协议决定。

1. 默认情况：依据内存地址哈希

在 Python 中，如果定义一个最普通的空类，其生成的实例默认可以直接存入集合：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = Point(1, 2)
p2 = Point(1, 2)
s = {p1, p2}
print(len(s))  # 示例输出: 2

为什么内容完全相同的 p1 和 p2 没有被去重？因为未重写特殊方法时，对象继承自 object 基类，其 __hash__() 直接使用对象的内存地址（id(self)），且 __eq__() 比较的也是引用身份（self is other）。由于它们处于不同内存位置，因此集合认为它们是两个互不相同的元素。

2. 常见陷阱：仅重写 __eq__ 会导致对象变为不可哈希

很多开发者为了让 p1 == p2 成立，会在类中编写 __eq__ 方法：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return isinstance(other, Point) and self.x == other.x and self.y == other.y

p = Point(1, 2)
s = {p}
# 立即抛出异常: TypeError: unhashable type: 'Point'

3. 正确方案：成对实现 __hash__ 与 __eq__

如果希望自定义对象既能按内容去重，又能安全存入集合，必须同时显式实现 __hash__ 和 __eq__，并确保作为哈希依据的属性在对象创建后不可更改：

class Point:
    def __init__(self, x, y):
        # 约定属性只读，防止哈希漂移
        self._x = x
        self._y = y

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

    def __eq__(self, other):
        if not isinstance(other, Point):
            return False
        return self._x == other._x and self._y == other._y

    def __hash__(self):
        # 使用只读属性打包成不可变元组计算哈希
        return hash((self._x, self._y))

# 测试使用
p1 = Point(1, 2)
p2 = Point(1, 2)
s = {p1, p2}
print(len(s))  # 示例输出: 1 （成功完成按内容识别与去重）

六、总结与实战选型清单

理解 Python 集合对数据的约束，核心在于把握“哈希表的稳定定位”与“可变对象的动态变更”之间的矛盾。在实际开发中，可以遵循以下四条通用准则：

1. 牢记基础分界线：数值、文本（str）、二进制字节（bytes）、不可变集合（frozenset）安全可用；列表（list）、字典（dict）、普通集合（set）绝对禁止。
2. 审查元组的纯洁性：元组仅具备浅层不可变性。在将元组存入集合之前，必须确保其内部所有层级的子元素均完全不可变。
3. 善用替代转换：当业务上需要将可变列表存入集合时，先使用 tuple(my_list) 进行冻结；当需要对集合嵌套去重时，内层集合使用 frozenset(my_sub_set)。
4. 自定义类规范：重写比较逻辑（__eq__）时务必配对实现 __hash__，且哈希算法所依赖的实例属性必须设计为只读，避免运行期间发生哈希漂移。