如何让Python子类根据条件仅继承两个父类中的一个？

你要实现的是运行时根据条件让子类仅表现出其中一个父类的行为，Python的静态继承机制没法直接在类初始化时修改继承关系，但可以通过几种更合理的方式实现需求，__getattribute__确实可行但不是最优解，下面逐一说明：

一、工厂函数（最推荐，逻辑清晰） #

直接写一个工厂函数，根据条件返回对应父类的实例（或它们的子类实例），完全避开多重继承的问题：

class ParA:
    def __init__(self) -> None:
        pass

    def f(self):
        print("method in parA")


class ParB:
    def __init__(self) -> None:
        pass

    def f(self):
        print("method in parB")

# 工厂函数：根据条件创建对应类的实例
def create_child(condition):
    if condition == "some_condition":
        return ParA()
    elif condition == "some_other_condition":
        return ParB()

# 使用示例
child = create_child("some_condition")
child.f()  # 输出: method in parA

如果你的Child需要有自己专属的属性或方法，可以先定义一个基类，让ParA、ParB和Child都继承它，再在工厂函数里返回Child的子类实例：

class Base:
    def child_specific_method(self):
        print("专属子类方法")

class ParA(Base):
    def f(self):
        print("method in parA")

class ParB(Base):
    def f(self):
        print("method in parB")

def create_child(condition):
    if condition == "some_condition":
        class Child(ParA): pass
    else:
        class Child(ParB): pass
    return Child()

child = create_child("some_other_condition")
child.f()  # 输出: method in parB
child.child_specific_method()  # 输出: 专属子类方法

二、动态切换实例的类（适合保留Child自身逻辑的场景） #

如果Child本身有固定的属性或方法，需要保留这些逻辑的同时切换父类行为，可以在初始化时修改实例的__class__属性：

class ParA:
    def f(self):
        print("method in parA")

class ParB:
    def f(self):
        print("method in parB")

class BaseChild:
    def __init__(self, condition):
        self.condition = condition
        # 根据条件切换实例所属的类
        if condition == "some_condition":
            self.__class__ = ChildA
        elif condition == "some_other_condition":
            self.__class__ = ChildB

    # Child自身的固定方法
    def say_hello(self):
        print("Hello from Child")

class ChildA(BaseChild, ParA):
    pass

class ChildB(BaseChild, ParB):
    pass

# 使用示例
child = BaseChild("some_condition")
child.f()  # 输出: method in parA
child.say_hello()  # 输出: Hello from Child

三、用__getattribute__实现（不推荐，维护成本高） #

你提到的__getattribute__方法确实能拦截属性访问，强制根据条件选择父类的方法，但这种方式会破坏Python默认的方法解析顺序（MRO），容易引发难以排查的bug，仅作为备选方案：

class ParA:
    def f(self):
        print("method in parA")

class ParB:
    def f(self):
        print("method in parB")

class Child(ParA, ParB):
    def __init__(self, condition):
        self.condition = condition

    def __getattribute__(self, name):
        # 先获取自身属性，避免递归调用__getattribute__
        try:
            return super().__getattribute__(name)
        except AttributeError:
            pass

        # 根据条件选择要查找的父类
        target_parent = ParA if self.condition == "some_condition" else ParB

        # 从目标父类中查找属性
        try:
            return getattr(target_parent, name)
        except AttributeError:
            raise AttributeError(f"'Child' object has no attribute '{name}'")

# 使用示例
child1 = Child("some_condition")
child1.f()  # 输出: method in parA

child2 = Child("some_other_condition")
child2.f()  # 输出: method in parB

注意事项： #

• 这种方式要特别小心处理自身属性的访问（比如self.condition），必须先用super().__getattribute__获取，否则会无限递归。
• 如果父类中有依赖实例状态的方法，这种直接调用类方法的方式可能不符合预期（因为没有绑定实例），需要改成getattr(target_parent(), name)，但这样会创建新的父类实例，逻辑更复杂。

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