Python多继承中如何创建不覆盖父类的方法存根？

你遇到的核心问题是Python多继承的MRO（方法解析顺序）机制导致Mixin中的抽象存根方法覆盖了另一个Mixin的有效实现。示例中，ChildA(MixinA, MixinB)会因为MRO优先加载MixinA的mid_level（抛出NotImplementedError）而无法正常运行，反之ChildB则会因为MixinB的low_level存根报错。

现有的两种方案要么丢失类型提示和接口约束，要么无法灵活适配所有场景，以下是几个更实用的解决思路：

方案1：让抽象存根优先调用父类实现 #

修改Mixin中的抽象方法，先通过super()尝试调用MRO链中的下一个实现，只有当没有任何父类提供实现时才抛出错误。这种方式不依赖固定继承顺序，同时保留了接口提示作用。

修改后的代码：

class MixinA:
    def high_level(self):
        self.mid_level()

    def low_level(self):
        print("执行MixinA的low_level逻辑")

    def mid_level(self):
        try:
            # 优先调用MRO链中后续类的mid_level实现
            return super().mid_level()
        except AttributeError:
            # 没有任何实现时才抛出错误
            raise NotImplementedError


class MixinB:
    def mid_level(self):
        self.low_level()

    def low_level(self):
        try:
            return super().low_level()
        except AttributeError:
            raise NotImplementedError


class ChildA(MixinA, MixinB):
    pass


class ChildB(MixinB, MixinA):
    pass


for cls in (ChildA, ChildB):
    try:
        cls().high_level()
        print("success")
    except NotImplementedError:
        print("error")

运行后两个子类都会输出success，因为MixinA的mid_level会调用MixinB的实现，MixinB的low_level会调用MixinA的实现，无论继承顺序如何。

方案2：拆分接口与实现，使用抽象基类（ABC） #

单独定义一个包含所有抽象方法的基类，Mixin仅提供具体实现逻辑，子类同时继承抽象基类和所需Mixin。这种方式既保留了清晰的接口定义和类型提示，又避免了存根覆盖实现的问题。

示例代码：

from abc import ABC, abstractmethod

# 定义完整的接口约束
class CoreInterface(ABC):
    @abstractmethod
    def high_level(self):
        pass
    
    @abstractmethod
    def mid_level(self):
        pass
    
    @abstractmethod
    def low_level(self):
        pass

# Mixin仅提供部分方法的实现
class MixinA:
    def high_level(self):
        self.mid_level()
    
    def low_level(self):
        print("执行MixinA的low_level逻辑")

class MixinB:
    def mid_level(self):
        self.low_level()

# 子类继承接口和Mixin，自动满足接口约束
class Child(CoreInterface, MixinA, MixinB):
    pass

Child().high_level()  # 正常执行，输出对应内容

这里CoreInterface确保了子类必须实现所有方法，而MixinA和MixinB的实现会自动覆盖抽象方法，无需担心存根冲突。

方案3：动态检查子类的方法实现 #

利用__init_subclass__钩子在子类创建时自动检查是否所有必要方法都已实现，提前发现问题，同时保留Mixin的灵活性。

示例代码：

class MixinA:
    def high_level(self):
        self.mid_level()

    def low_level(self):
        print("执行MixinA的low_level逻辑")

    @classmethod
    def __init_subclass__(cls):
        required_methods = ['mid_level']
        for method in required_methods:
            if not any(method in base.__dict__ for base in cls.__mro__[1:]):
                raise TypeError(f"子类{cls.__name__}必须实现{method}方法")


class MixinB:
    def mid_level(self):
        self.low_level()

    @classmethod
    def __init_subclass__(cls):
        required_methods = ['low_level']
        for method in required_methods:
            if not any(method in base.__dict__ for base in cls.__mro__[1:]):
                raise TypeError(f"子类{cls.__name__}必须实现{method}方法")


class ChildA(MixinA, MixinB):
    pass

class ChildB(MixinB, MixinA):
    pass

# 实例化时不会报错，因为两个Mixin互相补充了方法
ChildA().high_level()  # 正常执行

这种方式在子类定义阶段就会验证方法完整性，避免运行时抛出NotImplementedError，同时不需要依赖固定继承顺序。

关于你提到的“标记方法为virtual不覆盖已有实现”：Python原生没有类似其他语言的virtual关键字，但上述方案1本质上实现了类似效果——让存根方法仅在没有其他实现时生效，不会覆盖已有方法。

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