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)有关。
当前回答
关于@calfzhou的评论，你可以像往常一样使用**kwargs:
在线运行示例
class A(object):
def __init__(self, a, *args, **kwargs):
print("A", a)
class B(A):
def __init__(self, b, *args, **kwargs):
super(B, self).__init__(*args, **kwargs)
print("B", b)
class A1(A):
def __init__(self, a1, *args, **kwargs):
super(A1, self).__init__(*args, **kwargs)
print("A1", a1)
class B1(A1, B):
def __init__(self, b1, *args, **kwargs):
super(B1, self).__init__(*args, **kwargs)
print("B1", b1)
B1(a1=6, b1=5, b="hello", a=None)
结果:
A None
B hello
A1 6
B1 5
你也可以在不同的位置使用它们:
B1(5, 6, b="hello", a=None)
但你必须记住MRO，它真的很混乱。你可以通过使用关键字参数来避免这种情况:
class A(object):
def __init__(self, *args, a, **kwargs):
print("A", a)
等等。
我可能有点烦人，但我注意到人们每次重写一个方法时都会忘记使用*args和**kwargs，而这是这些“神奇变量”为数不多的真正有用和理智的使用之一。
其他回答
我想用“无生命”来详细说明这个答案，因为当我开始阅读如何在Python的多重继承层次结构中使用super()时，我并没有立即得到它。
你需要了解的是super(MyClass, self).__init__()在完整继承层次结构的上下文中根据所使用的方法解析排序(MRO)算法提供下一个__init__方法。
理解这最后一部分至关重要。让我们再考虑一下这个例子:
#!/usr/bin/env python2
class First(object):
def __init__(self):
print "First(): entering"
super(First, self).__init__()
print "First(): exiting"
class Second(object):
def __init__(self):
print "Second(): entering"
super(Second, self).__init__()
print "Second(): exiting"
class Third(First, Second):
def __init__(self):
print "Third(): entering"
super(Third, self).__init__()
print "Third(): exiting"
根据Guido van Rossum关于方法解析顺序的文章，解析__init__的顺序是使用“深度优先的从左到右遍历”来计算的(在Python 2.3之前):
Third --> First --> object --> Second --> object
删除所有重复项后，除了最后一个，我们得到:
Third --> First --> Second --> object
那么，让我们来看看当我们实例化一个Third类的实例时会发生什么，例如x = Third()。
According to MRO Third.__init__ executes. prints Third(): entering then super(Third, self).__init__() executes and MRO returns First.__init__ which is called. First.__init__ executes. prints First(): entering then super(First, self).__init__() executes and MRO returns Second.__init__ which is called. Second.__init__ executes. prints Second(): entering then super(Second, self).__init__() executes and MRO returns object.__init__ which is called. object.__init__ executes (no print statements in the code there) execution goes back to Second.__init__ which then prints Second(): exiting execution goes back to First.__init__ which then prints First(): exiting execution goes back to Third.__init__ which then prints Third(): exiting
这详细说明了为什么实例化Third()会导致:
Third(): entering
First(): entering
Second(): entering
Second(): exiting
First(): exiting
Third(): exiting
从Python 2.3开始，MRO算法已经得到了改进，在复杂的情况下工作得很好，但我猜使用“深度优先的从左到右遍历”+“删除除最后一个重复项之外的重复项”在大多数情况下仍然有效(如果不是这样，请评论)。一定要阅读Guido的博客文章!
我知道这并没有直接回答super()问题，但我觉得它有足够的相关性来分享。
还有一种方法可以直接调用每个继承的类:
class First(object):
def __init__(self):
print '1'
class Second(object):
def __init__(self):
print '2'
class Third(First, Second):
def __init__(self):
Second.__init__(self)
请注意，如果你这样做，你将不得不手动调用每个，因为我很确定First的__init__()不会被调用。
关于@calfzhou的评论，你可以像往常一样使用**kwargs:
在线运行示例
class A(object):
def __init__(self, a, *args, **kwargs):
print("A", a)
class B(A):
def __init__(self, b, *args, **kwargs):
super(B, self).__init__(*args, **kwargs)
print("B", b)
class A1(A):
def __init__(self, a1, *args, **kwargs):
super(A1, self).__init__(*args, **kwargs)
print("A1", a1)
class B1(A1, B):
def __init__(self, b1, *args, **kwargs):
super(B1, self).__init__(*args, **kwargs)
print("B1", b1)
B1(a1=6, b1=5, b="hello", a=None)
结果:
A None
B hello
A1 6
B1 5
你也可以在不同的位置使用它们:
B1(5, 6, b="hello", a=None)
但你必须记住MRO，它真的很混乱。你可以通过使用关键字参数来避免这种情况:
class A(object):
def __init__(self, *args, a, **kwargs):
print("A", a)
等等。
我可能有点烦人，但我注意到人们每次重写一个方法时都会忘记使用*args和**kwargs，而这是这些“神奇变量”为数不多的真正有用和理智的使用之一。
在这种情况下，你试图继承的每个类都有自己的init位置参数，只需调用每个类自己的init方法，如果试图继承多个对象，则不要使用super。
class A():
def __init__(self, x):
self.x = x
class B():
def __init__(self, y, z):
self.y = y
self.z = z
class C(A, B):
def __init__(self, x, y, z):
A.__init__(self, x)
B.__init__(self, y, z)
>>> c = C(1,2,3)
>>>c.x, c.y, c.z
(1, 2, 3)
这就是所谓的钻石问题，该页面有一个关于Python的条目，但简而言之，Python将从左到右调用超类的方法。
