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，而这是这些“神奇变量”为数不多的真正有用和理智的使用之一。
其他回答
在这种情况下，你试图继承的每个类都有自己的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)
也许还可以添加一些东西，比如Django rest_framework和装饰器的一个小例子。这为隐含的问题提供了答案:“我为什么想要这个?”
如前所述:我们使用Django rest_framework，我们使用泛型视图，对于数据库中的每种类型的对象，我们发现我们有一个视图类为对象列表提供GET和POST，另一个视图类为单个对象提供GET、PUT和DELETE。
现在我们要用Django的login_required来装饰POST、PUT和DELETE。注意，这涉及到两个类，而不是两个类中的所有方法。
解决方案可以通过多重继承。
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
class LoginToPost:
@method_decorator(login_required)
def post(self, arg, *args, **kwargs):
super().post(arg, *args, **kwargs)
其他方法也是如此。
在我的具体类的继承列表，我将添加我的LoginToPost之前ListCreateAPIView和LoginToPutOrDelete之前RetrieveUpdateDestroyAPIView。我的具体类的get将保持未修饰。
另一个尚未涉及的点是传递初始化类的参数。由于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可能被多次调用，则会失败，这取决于实现。
总结一下:合作继承和初始化的超参数和特定参数不能很好地协同工作。
关于@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，而这是这些“神奇变量”为数不多的真正有用和理智的使用之一。
考虑子AB，父A和B在它们的构造函数中有关键字参数。
A B
\ /
AB
要初始化AB，需要显式调用父类构造函数，而不是使用super()。
例子:
class A():
def __init__(self, a="a"):
self.a = a
print(f"a={a}")
def A_method(self):
print(f"A_method: {self.a}")
class B():
def __init__(self, b="b"):
self.b = b
print(f"b={b}")
def B_method(self):
print(f"B_method: {self.b}")
def magical_AB_method(self):
print(f"magical_AB_method: {self.a}, {self.b}")
class AB(A,B):
def __init__(self, a="A", b="B"):
# super().__init__(a=a, b=b) # fails!
A.__init__(self, a=a)
B.__init__(self, b=b)
self.A_method()
self.B_method()
self.magical_AB_method()
A()
>>> a=a
B()
>>> b=b
AB()
>>> a=A
>>> b=B
>>> A_method: A
>>> B_method: B
为了演示两个父类被组合到子类中，请考虑在类B中定义的magical_AB_method。当从B的实例调用时，该方法失败，因为它不能访问A中的成员变量。然而，当从子类AB的实例调用时，该方法工作，因为它从A继承了所需的成员变量。
B().magical_AB_method()
>>> AttributeError: 'B' object has no attribute 'a'
AB().magical_AB_method()
>>> magical_AB_method: A, B
