多重继承调用顺序

Question

 A      B
| |   |   |
C D   E   F
| |   |   |
    G     H
      |
      I


user@ubuntu:~/Documents/Python/oop_python$ cat tt.py
class A:
    def call_me(self):
        print("A")

class C(A):
    def call_me(self):
        super().call_me()
        print("C")

class D(A):
    def call_me(self):
        super().call_me()
        print("D")

class B:
    def call_me(self):
        print("B")

class E(B):
    def call_me(self):
        super().call_me()
        print("E")

class F(B):
    def call_me(self):
        super().call_me()
        print("F")

class G(C, D, E):
    def call_me(self):
        super().call_me()
        print("G")

class H(F):
    def call_me(self):
        super().call_me()
        print("H")

class I(G, H):
    def call_me(self):
        super().call_me()
        print("I")


user@ubuntu:~/Documents/Python/oop_python$ python3.2 -i tt.py
>>> i = I()
>>> i.call_me()
A
D
C
G
I

问题>为什么B、E、F不打印？

//            updated based on comments from delnan

user@ubuntu:~/Documents/Python/oop_python$ cat tt.py
class BaseClass():
    def call_me(self):
        print("BaseClass")
    pass

class A(BaseClass):
    def call_me(self):
        super().call_me()
        print("A")

class C(A):
    def call_me(self):
        super().call_me()
        print("C")

class D(A):
    def call_me(self):
        super().call_me()
        print("D")

class B(BaseClass):
    def call_me(self):
        super().call_me()
        print("B")

class E(B):
    def call_me(self):
        super().call_me()
        print("E")

class F(B):
    def call_me(self):
        super().call_me()
        print("F")

class G(C, D, E):
    def call_me(self):
        super().call_me()
        print("G")

class H(F):
    def call_me(self):
        super().call_me()
        print("H")

class I(G, H):
    def call_me(self):
        super().call_me()
        print("I")

user@ubuntu:~/Documents/Python/oop_python$ python3.2 -i tt.py
>>> i = I()
>>> i.call_me()
BaseClass
B
F
H
E
A
D
C
G
I

Answer 1

一个常见的误解是 super() 将调用所有超类方法。不会的。它只会调用其中之一。哪一个是由super()根据一些特定的规则自动计算出来的。有时，它调用的不是实际的超类，而是兄弟类。但不能保证所有类都会被调用，除非所有类都依次使用 super()。

在这种情况下，A和B没有调用super。如果你将它添加到 A，它实际上会调用“丢失”的类，但如果你将它添加到 B，你会得到一个错误，因为在这种特殊情况下，B 最终将成为“最后一个”（或第一个，取决于你如何看待它）类。

如果要使用 super()，最好的解决方案是 A 和 B 有一个公共基类，实现 call_me，但不调用 super()。 （感谢 delnan 的建议）。

但是，如果您知道类层次结构，则可以直接调用超类方法，而不是使用 super()。请注意，在上面的情况下，并不意味着每个类都必须直接调用它的每个基类。因此，当您作为程序员无法完全控制类层次结构时（例如，如果您编写库或混合类），这没有用。那么你必须使用super()。

Answer 2

使用super的前提是该类必须是new-style。

python 中 super 有两种用例：

1. 单继承的类层次结构，super 可以用来引用父类而无需显式命名

2. 第二个用例是在动态执行环境中支持协作多重继承。

因此，第二种情况符合您的第二个示例条件。在这种情况下，子类将执行 bfs 遍历 以使确保每个覆盖基类方法仅被调用一次。您的继承树可以按照以下顺序重写为衬垫（遵循bfs遍历，从左到右）IGCDAEHFB BaseClass。

super 方法的定义是：

Super(type[,object-or-type])

它将返回一个代理对象，该代理对象将方法调用委托给 type 的父类或同级类。在 python 3.x 中，您可以直接调用 super() ，这与 super(currentClassName, self) 相同。这将得到bfs遍历生成的直接右父类的代理。因此方法 i.call_me() 将被调用为：

I.call_me -> G.call_me-> C.call_me-> D.call_me-> A.call_me-> E.call_me-> H.call_me-> F.call_me-> B.call_me-> BaseClass.call_me

两个示例之间的区别

正如您所问的，为什么第一个示例没有打印 B、E、F，因为继承图不是“菱形图”，这意味着 A.call_me B.call_me 是不同的方法。所以python只选择继承分支之一。

希望这有帮助。您还可以查看 python 类文档 了解更多详细信息