如何在不复制实例的情况下检测Python数据类是否被修改？

核心思路：递归计算嵌套结构的哈希值 #

直接遍历dataclass的字段，递归处理嵌套的dataclass和列表，仅对底层基本类型调用原生hash()，最后组合成整体哈希值，完全避免字符串序列化的开销。

实现递归哈希计算函数 #

import dataclasses
from typing import Any

def compute_hash(obj: Any) -> int:
    # 处理dataclass实例
    if dataclasses.is_dataclass(obj):
        # 按字段名排序，确保字段顺序不影响哈希（若dataclass字段固定可省略该步骤提升效率）
        sorted_fields = sorted(dataclasses.fields(obj), key=lambda f: f.name)
        field_hashes = []
        for field in sorted_fields:
            value = getattr(obj, field.name)
            field_hashes.append(compute_hash(value))
        # 用tuple包装后哈希，因为list不可哈希
        return hash(tuple(field_hashes))
    # 处理列表
    elif isinstance(obj, list):
        return hash(tuple(compute_hash(item) for item in obj))
    # 处理基本类型
    elif isinstance(obj, (str, int, bool, float)):
        return hash(obj)
    else:
        raise TypeError(f"不支持的类型: {type(obj)}")

使用方式 #

初始化dataclass时保存初始哈希，后续需要检测修改时重新计算哈希并对比：

from dataclasses import dataclass

@dataclass
class NestedItem:
    count: int
    label: str

@dataclass
class MainData:
    id: int
    items: list[NestedItem]

# 创建对象并记录初始哈希
data = MainData(id=100, items=[NestedItem(5, "apple"), NestedItem(3, "banana")])
initial_hash = compute_hash(data)

# 模拟修改
data.id = 200
data.items[0].count = 6

# 检测修改
current_hash = compute_hash(data)
print(initial_hash != current_hash)  # 输出: True

优化：缓存哈希值减少重复计算 #

如果对象不会被频繁修改，可以给dataclass添加哈希缓存，仅在属性修改时重置缓存，避免重复全量计算：

@dataclass
class NestedItem:
    count: int
    label: str
    _cached_hash: int = None

    def __post_init__(self):
        self._cached_hash = compute_hash(self)

    def __setattr__(self, name, value):
        if name != "_cached_hash":
            super().__setattr__(name, value)
            self._cached_hash = None

    def get_hash(self):
        if self._cached_hash is None:
            self._cached_hash = compute_hash(self)
        return self._cached_hash

@dataclass
class MainData:
    id: int
    items: list[NestedItem]
    _cached_hash: int = None

    def __post_init__(self):
        self._cached_hash = compute_hash(self)

    def __setattr__(self, name, value):
        if name != "_cached_hash":
            super().__setattr__(name, value)
            self._cached_hash = None

    def get_hash(self):
        if self._cached_hash is None:
            self._cached_hash = compute_hash(self)
        return self._cached_hash

# 修改compute_hash适配缓存逻辑
def compute_hash(obj: Any) -> int:
    if hasattr(obj, "get_hash"):
        return obj.get_hash()
    elif dataclasses.is_dataclass(obj):
        sorted_fields = sorted(dataclasses.fields(obj), key=lambda f: f.name)
        field_hashes = []
        for field in sorted_fields:
            if field.name == "_cached_hash":
                continue
            value = getattr(obj, field.name)
            field_hashes.append(compute_hash(value))
        return hash(tuple(field_hashes))
    elif isinstance(obj, list):
        return hash(tuple(compute_hash(item) for item in obj))
    elif isinstance(obj, (str, int, bool, float)):
        return hash(obj)
    else:
        raise TypeError(f"不支持的类型: {type(obj)}")

方案优势 #

• 低开销：直接递归处理字段，仅计算哈希值，无需生成大体积字符串，数据量越大优势越明显
• 精准性：任何字段（包括嵌套dataclass、列表元素）的修改都会导致哈希值变化
• 可扩展性：轻松支持新增的基本类型或嵌套dataclass

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