多重继承中的python'super' - 意外的代码输出

Question

我对 python OOP 比较陌生。 虽然我对 JAVA OOP 有一些经验，并且知道方法“super”的含义，但是当我有多重继承（JAVA 中不存在）时，我很难理解它在 python 中是如何工作的

在挖掘找到一些答案后，我根据继承图阅读到，python 为每个类制定了方法解析顺序 (MRO) 以确定查找实例方法的顺序。

我还读到 MRO 由“旧样式”或“新样式”决定，具体取决于我的 python 版本。 我有 python 3.7，所以我使用“新样式”方法。

如果我理解正确，每次我重写一个方法并调用“super”时，python 都会转到 MRO 中当前类之后出现的类中的方法。

确实，当我运行以下代码时：

class A(object):
    def go(self):
        print("go A go!")

class B(A):
    def go(self):
        super(B, self).go()
        print("go B go!")

class C(A):
    def go(self):
        super(C, self).go()
        print("go C go!")

class D(B,C):
    def go(self):
        super(D, self).go()
        print("go D go!")

if __name__ == "__main__":
    d = D()
    d.go()
    print(D.__mro__)

我得到了输出：

go A go!
go C go!
go B go!
go D go!
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

到目前为止一切顺利，但是当我尝试运行以下代码时：

class A(object):
    def foo(self):
        print('this is A')

class B(object):
    def foo(self):
        print('this is B')

class AB(A,B):
    def foo(self):
        super(AB,self).foo()
        print('this is AB')

if __name__ == '__main__':
    x = AB()
    x.foo()
    print(AB.__mro__)

我得到了输出：

this is A
this is AB
(<class '__main__.AB'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

而不是我预期的输出：

this is B
this is A
this is AB
(<class '__main__.AB'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

所以显然我不明白发生了什么......

对于这种情况的任何解释，以及关于 python 如何准确地确定 MRO（根据“新风格”）将不胜感激！

Answer 1

问题是您的类不是合作定义的。 A 和B 都认为它已经引入了foo，因此没有必要调用super().foo，因为它们都认为它将是任何潜在MRO 中定义foo 的最后一个类。 AB 证明不是这样的。

当您调用AB.foo 时，它首先会调用A.foo。但是，A.foo 不使用 super，因此链结束，B.foo 永远不会被调用。

在适当设计的层次结构中，一个类“引入”了一个方法，并负责通过不调用super来终止链。任何其他想要成为层次结构一部分的类都负责调用super。

在您的A/B/AB 案例中，您有几个选择：

1. 让A 和B 都继承自FooBase，并让它们中的每一个都从foo 的实现中调用super().foo()。 FooBase.foo 本身不调用super。

2. 不是直接从A 和B 继承AB，而是让它从围绕它们之一或两者的包装器继承，其中包装器正确地实现了协作继承。 （详情请参阅Python's super() considered super!.。）

   例如，这里我们将A 包装起来，并让B 作为foo 的基础：

   class A:
       def foo(self):
           print('this is A')
   
   
   class AWrapper:
       def __init__(self, **kwargs):
           super().__init__()
           self.a = A()
   
       def foo(self):
           super().foo()
           self.a.foo()
   
   
   class B(object):
       def foo(self):
           print('this is B')
   
   # Important: AWrapper must come first
   class AB(AWrapper, B):
       def foo(self):
           super().foo()
           print('this is AB')
   
   AB().foo()
   

注意，如果__init__ 本身需要在A 和B 中定义，这将变得更加复杂；有关使 __init__ 在协作继承设置中正常工作的更多建议，请参阅链接文章。