Python 的 super() 如何处理多重继承？

Question

我在 Python 面向对象编程方面几乎是新手，我无法理解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()运行，为什么？

如果你想运行另一个怎么办？ 我知道它与 Python 方法解析顺序（ MRO ）有关。

Answer 1

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 将是[Fourth, Second, Third, First].

顺便说一句：如果 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 的构建方式。 它们不打算打印"first\\nsecond\\third"或其他任何内容。 您可以——当然也应该使用示例，添加super()调用，看看会发生什么，并更深入地了解 Python 的继承模型。 但我的目标是保持简单并展示 MRO 是如何构建的。 它是按照我的解释构建的：

>>> Fourth.__mro__
(<class '__main__.Fourth'>,
 <class '__main__.Second'>, <class '__main__.Third'>,
 <class '__main__.First'>,
 <type 'object'>)

Answer 2

您的代码和其他答案都有问题。 他们缺少合作子类化工作所需的前两个类中的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("third")

super()调用在每一步查找 MRO 中的下一个方法，这就是为什么 First 和 Second 也必须拥有它，否则执行会在Second.__init__()结束时停止。

这就是我得到的：

>>> Third()
second
first
third

Answer 3

我想稍微详细说明一下这个答案，因为当我开始阅读如何在 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() 。

1. 根据 MRO Third.__init__执行。
   • 打印Third(): entering
   • 然后super(Third, self).__init__()执行并且 MRO 返回First.__init__被调用。
2. First.__init__执行。
   • 打印First(): entering
   • 然后super(First, self).__init__()执行并且 MRO 返回Second.__init__被调用。
3. Second.__init__执行。
   • 打印Second(): entering
   • 然后super(Second, self).__init__()执行并且 MRO 返回object.__init__被调用。
4. object.__init__执行（代码中没有打印语句）
5. 执行返回到Second.__init__然后打印Second(): exiting
6. 执行返回到First.__init__ ，然后打印First(): exiting
7. 执行返回到Third.__init__然后打印Third(): exiting

这详细说明了为什么实例化 Third() 会导致：

Third(): entering
First(): entering
Second(): entering
Second(): exiting
First(): exiting
Third(): exiting

MRO 算法从 Python 2.3 开始改进，在复杂情况下运行良好，但我想使用“深度优先从左到右遍历”+“去除最后一个重复”在大多数情况下仍然有效（请如果不是这种情况，请发表评论）。 请务必阅读 Guido 的博客文章！

Answer 4

这被称为钻石问题，该页面有一个关于 Python 的条目，但简而言之，Python 会从左到右调用超类的方法。

Answer 5

我知道这并没有直接回答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__()不会被调用。

Answer 6

这就是我如何解决具有不同变量的多重继承以进行初始化以及具有多个具有相同函数调用的 MixIn 的问题。 我必须显式地向传递的 **kwargs 添加变量，并添加一个 MixIn 接口作为超级调用的端点。

这里A是一个可扩展的基类， B和C是提供函数f MixIn 类。 A和B在他们的__init__都期望参数v并且C期望w 。 函数f接受一个参数y 。 Q继承自所有三个类。 MixInF是B和C的混合接口。

• 此代码的 IPython Notebook
• 带有代码示例的 Github Repo

class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

Answer 7

总体

假设所有的东西都来自object （如果不是，你就靠你自己了），Python 会根据你的类继承树计算方法解析顺序 (MRO)。 MRO 满足 3 个属性：

• 一个班的孩子在他们的父母之前
• 左父母先于右父母
• 一个类在 MRO 中只出现一次

如果不存在这样的排序，Python 会出错。 它的内部工作原理是类祖先的 C3 线性化。 在此处阅读所有相关信息： https : //www.python.org/download/releases/2.3/mro/

因此，在以下两个示例中，它是：

1. 孩子
2. 剩下
3. 对
4. 家长

当一个方法被调用时，该方法在 MRO 中第一次出现就是被调用的那个。 任何未实现该方法的类都将被跳过。 在该方法中对super任何调用都将调用该方法在 MRO 中的下一次出现。 因此，在继承中放置类的顺序以及在方法中调用super位置都很重要。

例子

以下所有示例都有类的菱形继承，如下所示：

    Parent
    /   \
   /     \
Left    Right
   \     /
    \   /
    Child

在每种方法中都以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):
        super(Child, self).__init__()
        print("child")

Child()输出：

parent
right
left
child
    

在每种方法中使用super last

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()输出：

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()输出：

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

Answer 8

关于@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 ，而这是对这些“神奇变量”的少数真正有用和合理的使用之一。

Answer 9

另一个尚未涉及的点是为类的初始化传递参数。 由于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__以更直接地分配参数很诱人，但如果超类中存在任何super调用和/或 MRO 更改并且类 A 可能会被多次调用，则取决于实现，则失败。

总结：协作继承和 super 以及用于初始化的特定参数不能很好地协同工作。

Answer 10

考虑调用从子类调用的super().Foo() 。 方法解析顺序 (MRO)方法是解析方法调用的顺序。

案例 1：单一继承

在这种情况下， super().Foo() 将在层次结构中向上搜索并考虑最接近的实现，如果找到，则引发异常。 在任何访问过的子类与其在层次结构中的超类之间，“是一个”关系将始终为真。 但是这个故事在多重继承中并不总是一样的。

案例 2：多重继承

在这里，同时寻找超（）。美孚（）实现，在层次结构可能会或可能不会有参观每一个类的关系。 考虑以下示例：

class A(object): pass
class B(object): pass
class C(A): pass
class D(A): pass
class E(C, D): pass
class F(B): pass
class G(B): pass
class H(F, G): pass
class I(E, H): pass

在这里， I是层次结构中的最低级。 I will 的层次结构图和 MRO

（红色数字显示 MRO）

MRO 是IECDAHFGB object

请注意，只有当它继承自它的所有子类都被访问过时，才会访问类X （即，您永远不应该访问一个类，它的箭头来自您尚未访问过的下面的类）。

在这里，请注意，在访问类C ， D被访问，尽管C和D没有它们之间的关系（但两者都与A有关系）。 这就是super()与单继承不同的地方。

考虑一个稍微复杂的例子：

（红色数字显示 MRO）

MRO 是IECHDAFGB object

在这种情况下，我们从I到E再到C 。 下一步是A ，但我们还没有访问D ，它是A的子类。 然而，我们不能访问D ，因为我们还没有访问H ，它是D一个子类。 叶H作为下一个要访问的班级。 请记住，如果可能，我们会尝试在层次结构中向上，因此我们访问其最左侧的超类D 。 在D之后，我们访问A ，但我们不能向上反对，因为我们还没有访问F 、 G和B 。 这些类依次完善了I的 MRO。

请注意，任何类都不能在 MRO 中出现多次。

这就是 super() 在继承层次结构中的查找方式。

资源来源：Richard L Halterman Python 编程基础

Answer 11

在 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 一次。 您可以通过调用获取该订单 。 先生：

第四 -> 第三 -> 第一 -> 第二 -> 基础 -> 对象

Answer 12

class First(object):
  def __init__(self, a):
    print "first", a
    super(First, self).__init__(20)

class Second(object):
  def __init__(self, a):
    print "second", a
    super(Second, self).__init__()

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__(10)
    print "that's it"

t = Third()

输出是

first 10
second 20
that's it

调用 Third() 定位在 Third 中定义的init 。 在该例程中调用 super 会调用 First 中定义的init 。 MRO=[第一，第二]。 现在，在 First 中定义的init 中调用 super 将继续搜索 MRO 并找到 Second 中定义的init ，并且对 super 的任何调用都将命中默认对象init 。 我希望这个例子澄清了这个概念。

如果你不从 First 调用 super。 链停止，您将获得以下输出。

first 10
that's it

Answer 13

我想补充@Visionscaper在顶部所说的内容：

Third --> First --> object --> Second --> object

在这种情况下，解释器不会过滤掉对象类，因为它是重复的，而是因为 Second 出现在层次结构子集中的头部位置而不出现在尾部位置。 而object只出现在尾部位置，在C3算法中不被认为是确定优先级的强位置。

类 C 的线性化 (mro) L(C) 是

• 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"

Answer 14

在 learningpythonthehardway 中，如果没有记错的话，我学到了一个叫做 super() 的内置函数。 调用 super() 函数可以帮助继承通过父级和兄弟级，帮助你看的更清楚。 我仍然是初学者，但我喜欢分享我在 python2.7 中使用这个 super() 的经验。

如果您已阅读此页面中的评论，您将听到方法解析顺序 (MRO)，该方法是您编写的函数，MRO 将使用深度优先从左到右方案来搜索和运行。 你可以做更多的研究。

通过添加 super() 函数

super(First, self).__init__() #example for class First.

您可以使用 super() 连接多个实例和“家庭”，方法是添加其中的每个人。 它将执行方法，通过它们并确保您没有错过！ 但是，在之前或之后添加它们确实会有所不同，如果您已经完成了 learningpythonthehardway 练习 44，您就会知道。让乐趣开始吧！

以下面的示例为例，您可以复制粘贴并尝试运行它：

class First(object):
    def __init__(self):

        print("first")

class Second(First):
    def __init__(self):
        print("second (before)")
        super(Second, self).__init__()
        print("second (after)")

class Third(First):
    def __init__(self):
        print("third (before)")
        super(Third, self).__init__()
        print("third (after)")


class Fourth(First):
    def __init__(self):
        print("fourth (before)")
        super(Fourth, self).__init__()
        print("fourth (after)")


class Fifth(Second, Third, Fourth):
    def __init__(self):
        print("fifth (before)")
        super(Fifth, self).__init__()
        print("fifth (after)")

Fifth()

它是如何运行的？ Fifth() 的实例将是这样的。 每一步都从一个类到另一个添加超级函数的类。

1.) print("fifth (before)")
2.) super()>[Second, Third, Fourth] (Left to right)
3.) print("second (before)")
4.) super()> First (First is the Parent which inherit from object)

找到了父级，它将继续进行第三和第四！！

5.) print("third (before)")
6.) super()> First (Parent class)
7.) print ("Fourth (before)")
8.) super()> First (Parent class)

现在已经访问了所有带有 super() 的类！ 父类已被找到并执行，现在它继续在继承中对函数进行拆箱以完成代码。

9.) print("first") (Parent)
10.) print ("Fourth (after)") (Class Fourth un-box)
11.) print("third (after)") (Class Third un-box)
12.) print("second (after)") (Class Second un-box)
13.) print("fifth (after)") (Class Fifth un-box)
14.) Fifth() executed

上面程序的结果：

fifth (before)
second (before
third (before)
fourth (before)
first
fourth (after)
third (after)
second (after)
fifth (after)

对我来说，通过添加 super() 可以让我更清楚地了解 python 将如何执行我的编码，并确保继承可以访问我想要的方法。

Answer 15

如果您尝试继承的每个类都有自己的 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)

Answer 16

也许还有一些可以添加的东西，一个带有 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将保持原样。

Answer 17

发布此答案以供我将来参考。

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类是object

Answer 18

考虑子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