python：多重继承设计

以下是python中oop设计场景的描述：

一位图书馆开发人员为其他人制作了两个类

a

和

B

：

class A:
    def foo(self):
        print('A')

class B(A):
    def foo(self):
        super().foo()
        print('B')

他们非常直观，在他的测试中工作正常：

A().foo()   #   A
B().foo()   #   AB

应用程序开发人员使用这个库，并希望在自己的应用程序中使用它 项目因此，他创建了两个新类

C

和

D

他决定

C

是

a

的一个子类，但是

C

不需要调用其超类实现：

class C(A):
    def foo(self):
        print('C')

他的

C

测试：

C().foo()   #   C

最后，

D

是来自

B

和

C

的最小多重继承

class D(B, C): pass

注意。如果要明确说明

D.foo（）

在这里的作用，可以使用

super（）.foo（）

或

B.foo（self）

，但结果相同：

class D(B, C):
    def foo(self):
        super().foo()   # semantic: call `foo` in *that* super class
        #B.foo(self)     # semantic: call `foo` in `B`

到目前为止，每一步都是简单而合乎逻辑的，对吗？但是当他测试

D

：

D().foo()   #   CB

假设

D

按

B

然后

C

的顺序扩展，则输出

CB

看起来不合逻辑；一 通常希望

D（）.foo（）

调用

B（）.foo（）

和

C（）.foo（）

中的至少一个，但是 这个结果既不是

AB

也不是

C

也不是

ABC

我的问题不是关于python中类继承或mro的机制；信息技术 is：为什么我们会在每种逻辑设计选择之后得到不合逻辑的结果 步具体来说，当我们在多重继承中使用

super（）

时，我们真的需要 检查整个类层次结构，以确保所涉及的每个类（可以在library、library of library等中定义）都正常工作 合作

我希望答案可以集中在应用程序开发人员的角度；他需要遵循什么原则才能知道库类在他自己的扩展类层次结构中正确工作

---

举一个更现实的例子，假设我们正在写一个野生动物的游戏；对于每种动物，我们需要实现它们在被踢时所说的话：

class Animal:
    def kick(self):
        return 'are you ok? '

class RunnableAnimal(Animal):
    def kick(self):
        return super().kick() + \
                'i am running away. '

class FuriousAnimal(Animal):
    def kick(self):
        return 'i am attacking you! '

class Tiger(RunnableAnimal, FuriousAnimal):
    def kick(self):
        return super().kick()

print(Tiger().kick())

输出：

i am attacking you! i am running away. 

---

这显然不合逻辑：老虎不能同时执行两种不同的动作

结果如预期。当您将

D

定义为从

B、C

继承时，

D

最终得到

D

->

B

->

C

->

a

的mro，因此当您调用

D（）.foo（）

时，您可以从

B

调用

super

，它调用并打印

C.foo

，然后打印“B”当

C.foo

返回时。这里不合逻辑的事情是

C.foo

返回并且不调用

super

@IainShelvington如果你在

C.foo（）

中调用

super（）.foo（）

，然后

C（）.foo（）

输出

AC

而不是

C

。这取决于你是在打印之前还是之后调用super，否？@IainShelvington是的，无论是

CA

还是

AC

都不是想要的

C

；你期望的输出是什么？您继承了一个类，该类决定不需要为

foo

方法调用

super

，这就是您得到的行为