使用多重继承调用父类 __init__，正确的方法是什么?

本文介绍了使用多重继承调用父类 __init__，正确的方法是什么?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

假设我有一个多继承场景:

Say I have a multiple inheritance scenario:

class A(object):
    # code for A here

class B(object):
    # code for B here

class C(A, B):
    def __init__(self):
        # What's the right code to write here to ensure
        # A.__init__ and B.__init__ get called?

编写C的__init__有两种典型的方法:

There's two typical approaches to writing C's __init__:

(旧式)ParentClass.__init__(self)
(新式)super(DerivedClass, self).__init__()

但是，无论哪种情况，如果父类(A 和 B)不要遵循相同的约定，那么代码将无法正常工作(有些可能会被遗漏，或者被多次调用).

However, in either case, if the parent classes (A and B) don't follow the same convention, then the code will not work correctly (some may be missed, or get called multiple times).

那么正确的方法又是什么呢?说保持一致，遵循其中之一"很容易，但是如果 A 或 B 来自 3rd 方库，那又如何?有没有一种方法可以确保所有父类构造函数都被调用(并且以正确的顺序，并且只调用一次)?

So what's the correct way again? It's easy to say "just be consistent, follow one or the other", but if A or B are from a 3rd party library, what then? Is there an approach that can ensure that all parent class constructors get called (and in the correct order, and only once)?

看看我的意思，如果我这样做:

to see what I mean, if I do:

class A(object):
    def __init__(self):
        print("Entering A")
        super(A, self).__init__()
        print("Leaving A")

class B(object):
    def __init__(self):
        print("Entering B")
        super(B, self).__init__()
        print("Leaving B")

class C(A, B):
    def __init__(self):
        print("Entering C")
        A.__init__(self)
        B.__init__(self)
        print("Leaving C")

然后我得到:

Entering C
Entering A
Entering B
Leaving B
Leaving A
Entering B
Leaving B
Leaving C

注意 B 的 init 被调用了两次.如果我这样做:

Note that B's init gets called twice. If I do:

class A(object):
    def __init__(self):
        print("Entering A")
        print("Leaving A")

class B(object):
    def __init__(self):
        print("Entering B")
        super(B, self).__init__()
        print("Leaving B")

class C(A, B):
    def __init__(self):
        print("Entering C")
        super(C, self).__init__()
        print("Leaving C")

然后我得到:

Entering C
Entering A
Leaving A
Leaving C

请注意，B 的 init 永远不会被调用.所以看来，除非我知道/控制我从(A 和 B)继承的类的初始化，否则我无法为我正在编写的类做出安全的选择(C).

Note that B's init never gets called. So it seems that unless I know/control the init's of the classes I inherit from (A and B) I cannot make a safe choice for the class I'm writing (C).

the

使用多重继承调用父类 init，正确的方法是什么?

问题描述

推荐答案