Python子类重写classmethod问题：简易ORM的方法访问困境

我完全懂你现在的困境——写简易ORM的时候，既要支持像User.get(pk)这种类层面的模型操作，又要支持user.save()这种实例层面的操作，直接重写方法的话，很容易因为类方法和实例方法的上下文冲突搞砸。比如你可能一开始尝试的代码会遇到这样的问题：

class BaseModel:
    @classmethod
    def get(cls, pk):
        # 基类类方法：根据主键查询实例
        instance = cls()
        instance.pk = pk
        return instance

    def save(self):
        # 基类实例方法：保存当前实例到数据库
        print("Saving instance...")

class User(BaseModel):
    # 想重写类方法get，但如果不加@classmethod，调用User.get(1)会报错
    def get(cls, pk):
        user = super().get(pk)
        user.role = "admin" if pk == 1 else "user"
        return user

    # 重写实例方法save没问题，但和类方法的重写方式不一致，维护起来容易混乱
    def save(self):
        print("Validating user data first...")
        super().save()

下面给你几个亲测好用的解决方案，完美解决这个问题：

方案1：用元类自动绑定方法类型 #

元类可以帮你在子类定义时，自动把指定方法转为类方法，不用手动加@classmethod装饰器，同时保持实例方法的原样。这样子类重写时只需要写普通方法，元类会帮你处理上下文：

class ORMMeta(type):
    def __new__(cls, name, bases, attrs):
        # 自动把名为get的方法转为类方法
        if 'get' in attrs and not isinstance(attrs['get'], classmethod):
            attrs['get'] = classmethod(attrs['get'])
        # 实例方法保持不变，比如save
        return super().__new__(cls, name, bases, attrs)

class BaseModel(metaclass=ORMMeta):
    def get(cls, pk):
        # 基类类方法逻辑
        instance = cls()
        instance.pk = pk
        return instance

    def save(self):
        # 基类实例方法逻辑
        print("Base save logic executed")

class User(BaseModel):
    # 子类直接重写get，元类会自动转为类方法
    def get(cls, pk):
        user = super().get(pk)
        user.role = "admin" if pk == 1 else "user"
        return user

    # 子类重写save，正常作为实例方法
    def save(self):
        print("Validating User data before save")
        super().save()

# 测试类方法
user = User.get(1)
print(user.role)  # 输出: admin

# 测试实例方法
user.name = "Andrey"
user.save()  # 输出: Validating User data before save → Base save logic executed

这个方案最优雅，完全隐藏了类方法的绑定细节，子类只需要专注于业务逻辑的重写。

方案2：拆分方法前缀，明确区分操作类型 #

如果不想用元类（比如怕元类的复杂度），最简单的方式是给类方法和实例方法加不同的前缀，彻底避免方法名冲突：

class BaseModel:
    # 类方法统一用find_前缀
    @classmethod
    def find_by_pk(cls, pk):
        instance = cls()
        instance.pk = pk
        return instance

    # 实例方法统一用save_前缀
    def save_instance(self):
        print("Base save logic")

class User(BaseModel):
    @classmethod
    def find_by_pk(cls, pk):
        user = super().find_by_pk(pk)
        user.role = "admin" if pk == 1 else "user"
        return user

    def save_instance(self):
        print("Validating User data")
        super().save_instance()

# 调用类方法
user = User.find_by_pk(1)
# 调用实例方法
user.save_instance()

这种方式虽然少了点“魔法”，但胜在直观易懂，新手也能快速上手，维护成本极低。

方案3：用自定义装饰器标记方法类型 #

如果你想兼顾灵活性和可读性，可以自定义装饰器来标记子类中哪些是类方法、哪些是实例方法，基类在初始化子类时自动处理绑定：

# 自定义装饰器，标记该方法是类方法重写
def orm_class_method(func):
    func._is_orm_class_method = True
    return func

# 自定义装饰器，标记该方法是实例方法重写
def orm_instance_method(func):
    func._is_orm_instance_method = True
    return func

class BaseModel:
    @classmethod
    def get(cls, pk):
        instance = cls()
        instance.pk = pk
        return instance

    def save(self):
        print("Base save logic")

    # 子类初始化时自动处理装饰器标记的方法
    def __init_subclass__(cls):
        for name, method in cls.__dict__.items():
            if hasattr(method, '_is_orm_class_method'):
                setattr(cls, name, classmethod(method))

class User(BaseModel):
    @orm_class_method
    def get(cls, pk):
        user = super().get(pk)
        user.role = "admin"
        return user

    @orm_instance_method
    def save(self):
        print("Validating User data")
        super().save()

# 测试
user = User.get(1)
user.save()

这个方案用装饰器清晰标记了方法类型，既保留了灵活性，又避免了元类的“黑魔法”，适合对代码可读性要求高的场景。

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