Python子类创建或反序列化时如何自动调用指定类方法？

我有一个classmethod，希望在其所属类的任意子类创建时自动调用。目前的实现是定义BaseData基类，子类通过_dataProperties指定需转为属性的参数，但需要手动调用initProperties方法生成属性，这不够优雅。

我曾尝试将代码放入__init__，但反序列化（unpickle）对象时__init__不会被调用。

具体问题如下：

1. 通用问题：是否有办法强制子类首次使用时调用指定函数（即使__init__未执行）？
2. 特定问题：若不行，反序列化时能否自动调用指定函数（如__init__或其他函数）？
3. 场景问题：是否有更好的方式实现当前动态生成属性的需求？

相关代码 #

class BaseData:
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False
    
    @classmethod
    def initProperties(cls):
        for k, v in cls._dataProperties.items():
            # Create dynamic getter and setter function
            getterFunc = eval(f'lambda self: self.getProperty("{k}")')
            setterFunc = eval(f'lambda self, v: self.setProperty("{k}", v)')

            # Make them a property
            setattr(cls, k, property(fget=getterFunc, fset=setterFunc))

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

ChildData.initProperties()

1. 强制子类首次使用时自动调用指定函数 #

可以利用**元类（metaclass）**实现。元类负责类的创建过程，当子类被定义时，元类的__init__方法会被触发，此时就能自动调用目标函数。

示例实现：

class BaseDataMeta(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        # 仅在子类（非BaseData本身）且定义了_dataProperties时调用
        if bases and hasattr(cls, '_dataProperties'):
            cls.initProperties()

class BaseData(metaclass=BaseDataMeta):
    @staticmethod
    def internalName(name: str) -> str:
        return '_' + name

    def __init__(self):
        for k, v in self._dataProperties.items():
            setattr(self, BaseData.internalName(k), v)
        self._isModified = False
    
    @classmethod
    def initProperties(cls):
        for k, v in cls._dataProperties.items():
            # 用闭包绑定k，替代不安全的eval
            def getter(self, k=k):
                return self.getProperty(k)
            def setter(self, val, k=k):
                self.setProperty(k, val)
            setattr(cls, k, property(fget=getter, fset=setter))

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

# 无需手动调用initProperties，子类定义后自动执行

2. 反序列化时自动调用指定函数 #

Python反序列化过程会调用对象的__setstate__方法（如果定义），可以用这个方法替代__init__完成初始化逻辑：

class BaseData(metaclass=BaseDataMeta):
    # 保留之前的方法...
    
    def __getstate__(self):
        # 返回需要序列化的对象状态
        return self.__dict__.copy()
    
    def __setstate__(self, state):
        # 反序列化时恢复状态，并执行初始化
        self.__dict__.update(state)
        # 补充初始化缺失的属性或逻辑
        if not hasattr(self, '_isModified'):
            self._isModified = False
        # 如需调用其他函数，直接在这里执行
        # self.custom_init_func()

如果想强制反序列化时调用__init__，可以自定义__reduce__方法，但这种方式复杂度高，一般优先用__setstate__。

3. 更优雅的动态生成属性方式 #

方案1：使用dataclasses模块（Python 3.7+） #

借助标准库的dataclasses简化初始化逻辑，配合元类自动生成属性：

from dataclasses import dataclass, field

def data_property(field_name):
    def getter(self):
        return self.getProperty(field_name)
    def setter(self, val):
        self.setProperty(field_name, val)
    return property(getter, setter)

class BaseDataMeta(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        if bases and hasattr(cls, '_dataProperties'):
            for k in cls._dataProperties:
                setattr(cls, k, data_property(k))

@dataclass
class BaseData(metaclass=BaseDataMeta):
    _isModified: bool = field(default=False, init=False)
    
    def __post_init__(self):
        # 初始化内部属性值
        for k, v in self._dataProperties.items():
            setattr(self, f'_{k}', v)
    
    def getProperty(self, name):
        return getattr(self, f'_{name}')
    
    def setProperty(self, name, val):
        setattr(self, f'_{name}', val)
        self._isModified = True

class ChildData(BaseData):
    _dataProperties = {
        'date': None,
        'value': '0',
    }

# 使用示例
data = ChildData()
data.value = "123"
print(data.value)  # 输出123
print(data._isModified)  # 输出True

方案2：移除eval改用闭包 #

原代码中eval既不安全也没必要，用闭包绑定变量（如第一个解决方案中的写法），可以避免变量捕获问题，同时提升代码安全性。

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