Python dataclass 的 frozen=True 为什么不能真正实现不可变对象

使用 dataclass 时，很多人会加上 frozen=True 参数，期望创建一个不可变对象（即创建后其属性值不能再被修改）。但经过测试，你会发现事情并非如此简单。本文将解释 frozen=True 的真实工作原理，揭示它的两个关键漏洞，并提供一个实现真正不可变对象的可靠方案。

1. frozen=True 到底做了什么？

当你在 dataclass 装饰器中设置 frozen=True 时，Python 会为你的类生成一个 __setattr__ 方法和一个 __delattr__ 方法。这两个方法在执行时会抛出 FrozenInstanceError 异常。

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: float
    y: float

这个 __setattr__ 方法的作用是阻止你对实例的属性进行“重新绑定”。也就是说，你无法用点号语法（.）对一个已存在的实例属性进行赋值。

p = Point(1.0, 2.0)
# 尝试修改
p.x = 3.0

运行上面的代码，你会立刻得到一个 dataclasses.FrozenInstanceError 异常。这看起来很符合预期，似乎对象确实被“冻结”了。

2. 为什么说它不是“真正”的不可变？

frozen=True 只解决了最表面的问题——防止属性被重新绑定。但它存在两个根本性的漏洞，使得对象内部状态仍然可能被改变。

漏洞一：对“可变类型”属性无效

frozen 机制只关心属性名（即“标签”）是否被重新绑定，它不检查属性值本身是否可变。

考虑一个存储坐标的列表：

@dataclass(frozen=True)
class MutablePoint:
    coords: list  # 这是一个可变类型

mp = MutablePoint([1, 2])
print(mp.coords)  # 输出: [1, 2]

# 这行代码不会报错！
mp.coords.append(3)
print(mp.coords)  # 输出: [1, 2, 3]

为什么没报错？ 因为你没有改变 coords 这个标签所指向的对象（它仍然指向同一个列表对象）。你修改的是那个列表对象自身的内容。frozen 的 __setattr__ 只拦截 mp.coords = [1, 2, 3] 这类重新绑定的尝试，而对 mp.coords.append() 这类修改操作无能为力。

漏洞二：可以绕过实例字典

每个 Python 对象都有一个 __dict__ 字典，存储其所有实例属性。虽然 frozen 拦截了点号赋值，但你可以直接操作这个内部字典。

p = Point(1.0, 2.0)

# 直接访问并修改实例的 __dict__
p.__dict__['x'] = 100.0
print(p.x)  # 输出: 100.0

这种操作完全绕过了 frozen 保护，因为它根本没有调用实例的 __setattr__ 方法。同理，使用 object.__setattr__ 这样的超级方法也可以绕过自定义的拦截逻辑。

3. 如何实现真正不可变的 dataclass？

要实现一个健壮的不可变对象，你需要一个“防御性编程”的组合拳。仅靠 frozen=True 是远远不够的。

核心思路：让 dataclass 负责语法层面的冻结（防止重新绑定），同时强制要求所有字段都是不可变类型，并在初始化后断开与任何可变数据的引用。

步骤 1：强制所有字段为不可变类型

dataclass 本身不会强制字段类型，但你可以利用类型注解和运行时检查来确保安全。更简单的方法是，只使用数字、字符串、元组、None 等内置的不可变类型，以及你自己的（同样不可变的） dataclass。

from dataclasses import dataclass

@dataclass(frozen=True)
class ImmutablePoint:
    # 1. 使用元组代替列表
    coords: tuple

# 这样，即使 coords 内部的元素可变（如列表），元组本身也禁止增删改其元素
# （注意：元组内部如果包含可变对象，该对象仍可变，但元组的“槽位”不可变）
point = ImmutablePoint((1, 2))
# 以下操作会引发 TypeError
# point.coords[0] = 100
# point.coords.append(3)

步骤 2：为可变的外部输入提供“防御性拷贝”

如果你的初始化参数可能是一个可变对象（如列表），你应该在 __init__ 中创建其不可变副本，而不是直接存储它的引用。

dataclass 提供了一个优雅的方案：使用 field 的 default_factory 和自定义的 __post_init__ 方法。

from dataclasses import dataclass, field

@dataclass(frozen=True)
class RobustImmutablePoint:
    # 2. 字段类型标注为不可变类型
    x: float
    y: float
    tags: tuple  # 存储元组而非列表

    # 3. 使用 __post_init__ 来处理可能传入的可变参数
    def __post_init__(self):
        # 假设我们允许在创建时传入一个列表作为初始标签
        # 但我们需要将其转换为元组
        # 注意：由于是 frozen=True，我们不能用 self.tags = ...，
        # 但可以使用 object.__setattr__ 来完成这个一次性的初始化。
        if not isinstance(self.tags, tuple):
            object.__setattr__(self, 'tags', tuple(self.tags))

# 创建实例
initial_tags = ['math', 'physics']  # 这是一个可变的列表
p = RobustImmutablePoint(1.0, 2.0, initial_tags)
print(p.tags)  # 输出: ('math', 'physics')

# 验证“不可变性”
# 1. 不能重新绑定
# p.tags = ['biology'] # FrozenInstanceError

# 2. 即使持有原始列表的引用，修改它也不会影响已经创建的元组
initial_tags.append('biology')
print(p.tags) # 输出仍然是: ('math', 'physics')

# 3. 元组自身也是不可变的
# p.tags[0] = 'history' # TypeError

最终方案：一个“终极”不可变 dataclass

结合以上所有点，一个真正健壮的不可变 dataclass 应该具备以下特征：

from dataclasses import dataclass, field

@dataclass(frozen=True)
class UltimateImmutable:
    """一个真正意义上的不可变数据类。"""
    name: str
    scores: tuple  # 关键：使用元组存储序列数据

    def __post_init__(self):
        """初始化后处理，用于‘防御性拷贝’。"""
        # 确保传入的 scores 被转换为元组
        # 由于 frozen=True，我们必须使用 object.__setattr__
        if not isinstance(self.scores, tuple):
            object.__setattr__(self, 'scores', tuple(self.scores))

# 使用演示
data = [98, 95, 100]
obj = UltimateImmutable('Alice', data)
print(obj.scores) # (98, 95, 100)

# 尝试各种方式破坏，均会失败或无法影响对象
data.pop() # 原始列表被修改，但对象内部元组不变
# obj.name = 'Bob' # FrozenInstanceError
# obj.scores = (1,) # FrozenInstanceError
# obj.scores[0] = 0 # TypeError
# obj.__dict__['name'] = 'Eve' # 绕过保护，但这是故意为之的极端案例，常规使用应避免

4. 何时使用 frozen=True？

理解了它的局限后，frozen=True 依然非常有用：

• 作为字典的键或集合的元素：这是 frozen 的核心设计目的之一。一个“冻结”的对象（假设其字段都是可哈希的）是可哈希的，可以放入 dict 或 set 中。
• 表达“值对象”语义：在领域驱动设计中，坐标、货币、颜色等值对象一旦创建就不应改变。frozen=True 向代码的阅读者清晰地传达了这一意图。
• 防止无意的修改：在团队协作中，它可以有效防止其他开发者不小心写出 obj.x = new_value 这样的代码，减少低级错误。

结论：将 frozen=True 视为一个语法级别的安全门禁和清晰的语义声明，而非一个能提供绝对安全的“保险箱”。要创建真正不可变的对象，必须将 frozen=True 与只使用不可变类型字段以及在初始化时进行防御性拷贝的策略结合起来使用。