在 python 中使用不同的参数调用超类构造函数

Posted 2023-02-24

【中文标题】在 python 中使用不同的参数调用超类构造函数

【英文标题】：Calling superclass constructors in python with different arguments

【发布时间】：2013-08-03 02:23:09

【问题描述】：

class A():
    def __init__( self, x, y):
        self.x = x
        self.y = y

class B():
    def __init__( self, z=0):
        self.z = z  

class AB(A,B):
    def __init__( self, x, y, z=0):
        ?

如何让 AB 的构造函数使用正确的参数调用 A 和 B 的构造函数？

我试过了

class AB(A,B):
    def __init__( self, x, y, z=0):
        A.__init__(x,y)
        B.__init__(z)

但这给了我一个错误。

【问题讨论】：

为什么在这里使用继承而不是委托？因为多继承的情况应该使用super来处理，因为__init__中的参数不同，所以效果不好。

@ovgolovin 因为我是一个没有经验的程序员。我不知道什么是代表团。我会试着调查一下。

【参考方案1】：

其他答案建议在第一个参数中添加self。

但通常在父类中调用__init__ 是由super 进行的。

考虑这个例子：

class A(object):
    def __init__(self, x):
        print('__init__ is called in A')
        self.x = x


class B(object):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in B')
        super(B, self).__init__(*args, **kwargs)


class AB(B, A):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in AB')
        super(AB, self).__init__(*args, **kwargs)

AB 类包含构造函数和初始化器的调用顺序：

>>> AB.__mro__
(<class '__main__.AB'>, <class '__main__.B'>, <class '__main__.A'>, <type 'object'>)

看，首先调用 AB 的 __init__，然后是 B，然后是 A，然后是 object。

让我们检查一下：

>>> ab = AB(1)
__init__ is called in AB
__init__ is called in B
__init__ is called in A

但是通过这个链的这些调用是由super 进行的。当我们输入super(AB, self)时，表示：在self的__mro__链中找到AB之后的下一个类。

那么我们应该在B中调用super，在B之后寻找链中的下一个类：super(B, self)。

使用super很重要，不要手动调用A.__init__(self,...)等，以后可能会出问题。 Read this for more info.

所以，如果你坚持使用super，那就有问题了。 __init__ 类中的方法需要不同的参数。而且您无法确定super 在这些类中调用方法的顺序。顺序由创建类时C3 algorithm 确定。在子类中，另一个类可能介于调用链之间。因此，__init__ 中不能有不同的参数，因为在这种情况下，您必须始终考虑所有继承链才能了解如何调用 __init__ 方法。

例如，考虑添加C(A) 和D(B) 类以及它们的CD 子类。那么A 将不再在B 之后被调用，而是在C 之后被调用。

class A(object):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in A')
        super(A, self).__init__(*args, **kwargs)


class B(object):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in B')
        super(B, self).__init__(*args, **kwargs)

class AB(B,A):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in AB')
        super(AB, self).__init__(*args, **kwargs)

class C(A):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in C')
        super(C, self).__init__(*args, **kwargs)

class D(B):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in D')
        super(D, self).__init__(*args, **kwargs)


class CD(D,C):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in CD')
        super(CD, self).__init__(*args, **kwargs)

class ABCD(CD,AB):
    def __init__(self, *args, **kwargs):
        print('__init__ is called in ABCD')
        super(ABCD, self).__init__(*args, **kwargs)




>>> abcd = ABCD()
__init__ is called in ABCD
__init__ is called in CD
__init__ is called in D
__init__ is called in AB
__init__ is called in B
__init__ is called in C
__init__ is called in A

所以我认为在这里考虑使用delegation 而不是继承是个好主意。

class AB(object):
    def __init__(self, x, y, z=0):
        self.a = A(x,y)
        self.b = B(z)

因此，您只需在 AB 对象中创建 A 和 B 类的 a 和 b 实例。然后可以通过引用self.a和self.b的方法根据需要使用。

使用或不使用委托取决于您的情况，您的问题并不清楚。但这可能是一个值得考虑的选择。

【参考方案2】：

你没有通过self。

class AB(A, B):
    def __init__(self, x, y, z=0):
        A.__init__(self, x, y)
        B.__init__(self, z)

请注意，如果此继承层次结构变得更加复杂，您将遇到构造函数不执行或重新执行的问题。查看super（以及problems 和super），如果您在2.x 上并且您的类没有从其他任何东西继承，请不要忘记从object 继承。