为冻结数据类层级实现含类型的哈希函数方案问询

问题背景 #

我有一个冻结数据类（frozen dataclasses）的层级结构，需要实现哈希功能，确保每个唯一实例的哈希值唯一。这里的“唯一”指实例的字段或类型不同。但默认数据类的__hash__仅基于字段而非类型，导致不同类型但字段相同的实例哈希值默认相同。

简化示例 #

以下是一个3级嵌套的数据类实现：

from dataclasses import dataclass
import abc

@dataclass(frozen=True)
class Element(abc.ABC):
    pass

@dataclass(frozen=True)
class StepType(Element, abc.ABC):
    @classmethod
    def name(cls):
        return cls.__name__

class Skip(StepType): pass
class Hop(StepType): pass

@dataclass(frozen=True)
class Stepper(Element, abc.ABC):
    step_type: StepType = Skip()
    foo: int = 1
    @abc.abstractmethod
    def step(self):
        pass

@dataclass(frozen=True)
class Single(Stepper):
    def step(self):
        return self.step_type.name() + " once"

@dataclass(frozen=True)
class Double(Stepper):
    def step(self):
        return self.step_type.name() + " twice"

@dataclass(frozen=True)
class Speed(Element, abc.ABC):
    @abc.abstractmethod
    def how_fast(self):
        pass

@dataclass(frozen=True)
class Slow(Speed):
    def how_fast(self):
        return "real slow"

@dataclass(frozen=True)
class Fast(Speed):
    def how_fast(self):
        return "quickly"

@dataclass(frozen=True)
class Walker:
    speed: Speed = Slow()
    stepper: Stepper = Single()

    def walk(self):
        return " ".join([self.stepper.step(), self.speed.how_fast()])

继承结构 #

Element
|- StepType
|  |- Skip
|  |- Hop
|
|- Stepper
|  |- Single
|  |- Double
|
|- Speed
   |- Slow
   |- Fast

嵌套结构 #

Walker
|- stepper: Stepper
|  |- step_type: StepType
| 
|- speed: Speed

测试行为 #

不同的Walker实例及其内部Element实例哈希值意外相同：

a = Walker(speed=Slow(), stepper=Single())
b = Walker(speed=Fast(), stepper=Double(step_type=Hop()))
print(f"a: {hash(a)}\nb: {hash(b)}")

输出：

>> a: -5704360693866892300
   b: -5704360693866892300

期望行为 #

确保唯一的Walker实例哈希值可靠不同，同时保留所有数据类原有功能。

约束条件 #

• 无需强制重写__hash__，可在Walker和/或Element中新增方法，但必须支持递归（Element实例可嵌套任意深度的其他Element）；理想情况是复用默认数据类可靠的__hash__实现，而非完全重写。
• 哈希值需可持久化到磁盘并跨运行读取，因此必须跨运行一致，不能依赖id(self)这类object.__hash__的依赖项。
• 除Walker外所有类必须继承自Element，不能将数据类重构为普通类、枚举等，必须使用数据类框架。

已有思路 #

我认为在哈希计算中加入repr(type(self))和字段信息可以解决问题，以下是两种尝试：

思路1：简单哈希异或 #

class Element:
    def hash(self):
        return hash(self) ^ hash(repr(type(self)))

问题：无法递归处理嵌套的Element实例，内部嵌套对象的哈希仍未包含类型信息。

思路2：递归哈希计算 #

这是目前我想到的最优方案：

class Element:
    def __hash__(self):
        return hash(
            hash(repr(type(self))) ^ 
            (hash(
                hash((key, val)) for key, val in self.__dict__.items()
                )**3
            )
        )

该方案支持递归，且通过了单元测试，但重写了内置数据类的__hash__，我担心会引发异常场景，希望得到更稳健的方案、指出潜在问题或确认该方案可行的建议。

解决方案建议 #

方案1：复用默认哈希+类型标识（推荐） #

既然希望复用数据类默认的__hash__，可以在Element中新增一个自定义哈希方法，递归计算包含类型信息的哈希值，而非重写__hash__：

import dataclasses

@dataclass(frozen=True)
class Element(abc.ABC):
    def custom_hash(self):
        # 收集当前实例的类型标识和所有字段的自定义哈希
        hash_components = [repr(type(self))]
        for field in dataclasses.fields(self):
            val = getattr(self, field.name)
            # 递归处理嵌套的Element实例
            if isinstance(val, Element):
                hash_components.append(val.custom_hash())
            else:
                hash_components.append(hash(val))
        # 对所有组件的哈希值组合计算最终哈希
        return hash(tuple(hash_components))

然后在Walker中也实现对应的方法：

@dataclass(frozen=True)
class Walker:
    # ... 原有代码 ...
    def custom_hash(self):
        hash_components = []
        for field in dataclasses.fields(self):
            val = getattr(self, field.name)
            if isinstance(val, Element):
                hash_components.append(val.custom_hash())
            else:
                hash_components.append(hash(val))
        return hash(tuple(hash_components))

优势：

• 完全复用数据类默认的字段哈希逻辑，避免重写__hash__带来的兼容性问题
• 递归处理所有嵌套的Element实例，确保类型信息被纳入哈希计算
• 跨运行一致，所有计算基于字段值和类型字符串，无依赖id()的内容

方案2：安全重写__hash__的优化版 #

如果一定要重写__hash__，可以优化思路2的实现，避免潜在问题：

import dataclasses

@dataclass(frozen=True)
class Element(abc.ABC):
    def __hash__(self):
        # 用tuple而非生成器，确保哈希计算的确定性（生成器的哈希在Python中是基于对象id的）
        field_hashes = tuple(
            hash((field.name, getattr(self, field.name))) 
            for field in dataclasses.fields(self)
        )
        # 组合类型哈希和字段哈希，用tuple而非异或+幂运算，避免哈希碰撞风险
        return hash((repr(type(self)), field_hashes))

关键优化点：

• 使用dataclasses.fields(self)而非直接访问__dict__，确保只处理数据类的字段（避免继承来的非字段属性）
• 用tuple存储字段哈希而非生成器，因为生成器的哈希值依赖其内存地址（id()），跨运行会变化，违反约束
• 直接将类型标识和字段哈希元组组合后计算哈希，比异或+幂运算的碰撞风险更低，逻辑更清晰

对思路2的潜在问题分析 #

1. 生成器哈希的不确定性：思路2中hash((key, val) for key, val in self.__dict__.items())是对生成器对象计算哈希，而生成器的哈希依赖其内存地址（id()），跨运行会变化，违反“哈希值跨运行一致”的约束。
2. __dict__的不可靠性：直接访问self.__dict__可能包含非数据类字段的属性（如继承来的方法、ABC的特殊属性），导致哈希计算包含无关信息。
3. 幂运算的哈希碰撞风险：hash(...)**3会放大哈希值，但可能增加碰撞概率，且无必要——直接组合哈希组件更可靠。

内容的提问来源于stack exchange，提问作者obviouslyalive