super()如何处理多重继承?例如，给定:
class First(object):
def __init__(self):
print "first"
class Second(object):
def __init__(self):
print "second"
class Third(First, Second):
def __init__(self):
super(Third, self).__init__()
print "that's it"
Third的哪个父方法执行super()。__init__ refer to?我可以选择哪些运行吗?
我知道这与方法解析顺序(MRO)有关。
当前回答
Guido在他的博客文章Method Resolution Order(包括两个早期的尝试)中对此进行了详细的描述。
在你的例子中，Third()将调用First.__init__。Python按照从左到右列出的顺序在类的父类中查找每个属性。在本例中，我们正在寻找__init__。如果你定义
class Third(First, Second):
...
Python将首先查看First，如果First没有该属性，那么它将查看Second。
当继承开始交叉路径时(例如First从Second继承)，这种情况会变得更加复杂。阅读上面的链接了解更多细节，但是，简而言之，Python将试图保持每个类在继承列表中出现的顺序，从子类本身开始。
例如，如果你有:
class First(object):
def __init__(self):
print "first"
class Second(First):
def __init__(self):
print "second"
class Third(First):
def __init__(self):
print "third"
class Fourth(Second, Third):
def __init__(self):
super(Fourth, self).__init__()
print "that's it"
MRO为[第四、第二、第三、第一]。
顺便说一下:如果Python无法找到一致的方法解析顺序，它将引发异常，而不是退回到可能使用户感到惊讶的行为。
模棱两可的MRO示例:
class First(object):
def __init__(self):
print "first"
class Second(First):
def __init__(self):
print "second"
class Third(First, Second):
def __init__(self):
print "third"
Third的MRO是[First, Second]还是[Second, First]?没有明显的期望，Python将引发一个错误:
TypeError: Error when calling the metaclass bases
Cannot create a consistent method resolution order (MRO) for bases Second, First
为什么上面的例子没有super()调用?这些示例的重点是展示MRO是如何构造的。他们不打算打印“第一\第二\第三”或其他什么。当然，您可以(也应该)尝试一下这个示例，添加super()调用，看看会发生什么，并更深入地理解Python的继承模型。但我的目标是保持简单，并展示MRO是如何构建的。正如我解释的那样:
>>> Fourth.__mro__
(<class '__main__.Fourth'>,
<class '__main__.Second'>, <class '__main__.Third'>,
<class '__main__.First'>,
<type 'object'>)
其他回答
另一个尚未涉及的点是传递初始化类的参数。由于super的目标取决于子类，传递参数的唯一好方法是将它们打包在一起。然后注意不要让相同的参数名具有不同的含义。
例子:
class A(object):
def __init__(self, **kwargs):
print('A.__init__')
super().__init__()
class B(A):
def __init__(self, **kwargs):
print('B.__init__ {}'.format(kwargs['x']))
super().__init__(**kwargs)
class C(A):
def __init__(self, **kwargs):
print('C.__init__ with {}, {}'.format(kwargs['a'], kwargs['b']))
super().__init__(**kwargs)
class D(B, C): # MRO=D, B, C, A
def __init__(self):
print('D.__init__')
super().__init__(a=1, b=2, x=3)
print(D.mro())
D()
给:
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D.__init__
B.__init__ 3
C.__init__ with 1, 2
A.__init__
直接调用超类__init__来更直接地赋值参数是很诱人的，但如果在超类中有任何超调用和/或MRO被更改并且类a可能被多次调用，则会失败，这取决于实现。
总结一下:合作继承和初始化的超参数和特定参数不能很好地协同工作。
我想补充一下@Visionscaper在开头说的话:
Third --> First --> object --> Second --> object
在这种情况下，解释器不会过滤掉对象类，因为它是重复的，而是因为Second出现在一个层次结构子集的头部位置，而不是尾部位置。而在C3算法中，对象只出现在尾部位置，不被认为是一个强位置来确定优先级。
线性化(mro)的类C, L(C)，是
丙类 加上归并 线性化父函数P1, P2， ..= L(P1, P2，… 它的父元素P1, P2， ..
线性化合并是通过选择出现在列表头部而不是尾部的公共类来完成的，因为顺序很重要(下面会清楚地说明)
Third的线性化计算如下:
L(O) := [O] // the linearization(mro) of O(object), because O has no parents
L(First) := [First] + merge(L(O), [O])
= [First] + merge([O], [O])
= [First, O]
// Similarly,
L(Second) := [Second, O]
L(Third) := [Third] + merge(L(First), L(Second), [First, Second])
= [Third] + merge([First, O], [Second, O], [First, Second])
// class First is a good candidate for the first merge step, because it only appears as the head of the first and last lists
// class O is not a good candidate for the next merge step, because it also appears in the tails of list 1 and 2,
= [Third, First] + merge([O], [Second, O], [Second])
// class Second is a good candidate for the second merge step, because it appears as the head of the list 2 and 3
= [Third, First, Second] + merge([O], [O])
= [Third, First, Second, O]
因此，对于下面代码中的super()实现:
class First(object):
def __init__(self):
super(First, self).__init__()
print "first"
class Second(object):
def __init__(self):
super(Second, self).__init__()
print "second"
class Third(First, Second):
def __init__(self):
super(Third, self).__init__()
print "that's it"
很明显，这个方法将如何解决
Third.__init__() ---> First.__init__() ---> Second.__init__() --->
Object.__init__() ---> returns ---> Second.__init__() -
prints "second" - returns ---> First.__init__() -
prints "first" - returns ---> Third.__init__() - prints "that's it"
整体
假设所有东西都来自object(如果不是你自己的)，Python会根据你的类继承树计算一个方法解析顺序(MRO)。MRO满足3个性质:
一个阶层的孩子比他们的父母更重要 左父母先于右父母 一个类在MRO中只出现一次
如果不存在这样的顺序，Python将出错。它的内部工作原理是类祖先的C3线性化。点击这里阅读:https://www.python.org/download/releases/2.3/mro/
当一个方法被调用时，该方法在MRO中第一次出现就是被调用的方法。任何没有实现该方法的类都将被跳过。在该方法中对super的任何调用都将调用MRO中该方法的下一次出现。因此，在继承中放置类的顺序以及在方法中放置super调用的位置都很重要。
注意，你可以通过使用__mro__方法在python中看到MRO。
例子
下面所有的例子都有菱形类继承，如下所示:
Parent
/ \
/ \
Left Right
\ /
\ /
Child
MRO是:
孩子 左 正确的 父
您可以通过调用Child来测试这一点。__mro__，返回:
(__main__.Child, __main__.Left, __main__.Right, __main__.Parent, object)
每一种方法都以超第一
class Parent(object):
def __init__(self):
super(Parent, self).__init__()
print("parent")
class Left(Parent):
def __init__(self):
super(Left, self).__init__()
print("left")
class Right(Parent):
def __init__(self):
super(Right, self).__init__()
print("right")
class Child(Left, Right):
def __init__(self):
super(Child, self).__init__()
print("child")
孩子()输出:
parent
right
left
child
在每个方法中都有超级最后
class Parent(object):
def __init__(self):
print("parent")
super(Parent, self).__init__()
class Left(Parent):
def __init__(self):
print("left")
super(Left, self).__init__()
class Right(Parent):
def __init__(self):
print("right")
super(Right, self).__init__()
class Child(Left, Right):
def __init__(self):
print("child")
super(Child, self).__init__()
孩子()输出:
child
left
right
parent
当不是所有类都调用super时
如果不是继承链中的所有类都调用super，那么继承顺序最重要。例如，如果Left不调用super，那么Right和Parent上的方法永远不会被调用:
class Parent(object):
def __init__(self):
print("parent")
super(Parent, self).__init__()
class Left(Parent):
def __init__(self):
print("left")
class Right(Parent):
def __init__(self):
print("right")
super(Right, self).__init__()
class Child(Left, Right):
def __init__(self):
print("child")
super(Child, self).__init__()
孩子()输出:
child
left
或者，如果Right没有调用super, Parent仍然被跳过:
class Parent(object):
def __init__(self):
print("parent")
super(Parent, self).__init__()
class Left(Parent):
def __init__(self):
print("left")
super(Left, self).__init__()
class Right(Parent):
def __init__(self):
print("right")
class Child(Left, Right):
def __init__(self):
print("child")
super(Child, self).__init__()
在这里，Child()输出:
child
left
right
调用特定父节点上的方法
如果你想访问一个特定父类的方法，你应该直接引用这个类，而不是使用super。Super是关于遵循继承链，而不是到达特定类的方法。
下面是如何引用一个特定的父方法:
class Parent(object):
def __init__(self):
super(Parent, self).__init__()
print("parent")
class Left(Parent):
def __init__(self):
super(Left, self).__init__()
print("left")
class Right(Parent):
def __init__(self):
super(Right, self).__init__()
print("right")
class Child(Left, Right):
def __init__(self):
Parent.__init__(self)
print("child")
在这种情况下，Child()输出:
parent
child
在python 3.5+中，继承看起来是可预测的，对我来说非常好。 请看下面的代码:
class Base(object):
def foo(self):
print(" Base(): entering")
print(" Base(): exiting")
class First(Base):
def foo(self):
print(" First(): entering Will call Second now")
super().foo()
print(" First(): exiting")
class Second(Base):
def foo(self):
print(" Second(): entering")
super().foo()
print(" Second(): exiting")
class Third(First, Second):
def foo(self):
print(" Third(): entering")
super().foo()
print(" Third(): exiting")
class Fourth(Third):
def foo(self):
print("Fourth(): entering")
super().foo()
print("Fourth(): exiting")
Fourth().foo()
print(Fourth.__mro__)
输出:
Fourth(): entering
Third(): entering
First(): entering Will call Second now
Second(): entering
Base(): entering
Base(): exiting
Second(): exiting
First(): exiting
Third(): exiting
Fourth(): exiting
(<class '__main__.Fourth'>, <class '__main__.Third'>, <class '__main__.First'>, <class '__main__.Second'>, <class '__main__.Base'>, <class 'object'>)
正如你所看到的，它对每个继承链调用foo一次，其顺序与继承链的顺序相同。你可以通过调用.mro来获得订单:
Fourth -> Third -> First -> Second -> Base ->对象
把这个答案贴出来供我将来参考。
Python多重继承应该使用菱形模型，并且函数签名不应该在模型中更改。
A
/ \
B C
\ /
D
示例代码片段为;-
class A:
def __init__(self, name=None):
# this is the head of the diamond, no need to call super() here
self.name = name
class B(A):
def __init__(self, param1='hello', **kwargs):
super().__init__(**kwargs)
self.param1 = param1
class C(A):
def __init__(self, param2='bye', **kwargs):
super().__init__(**kwargs)
self.param2 = param2
class D(B, C):
def __init__(self, works='fine', **kwargs):
super().__init__(**kwargs)
print(f"{works=}, {self.param1=}, {self.param2=}, {self.name=}")
d = D(name='Testing')
这里类A是对象
