Python的“超级”是如何实现的？ 做正确的事吗？

Question

我正在运行Python 2.5，所以这个问题可能不适用于Python 3。当您使用多重继承创建菱形类层次结构并创建最派生类的对象时，Python 会做正确的事情（TM）。 它调用最派生类的构造函数，然后调用从左到右列出的其父类，最后调用祖父类。 我熟悉Python的MRO； 这不是我的问题。 我很好奇从 super 返回的对象实际上如何设法以正确的顺序与父类中的 super 调用进行通信。 考虑这个示例代码：

#!/usr/bin/python

class A(object):
    def __init__(self): print "A init"

class B(A):
    def __init__(self):
        print "B init"
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print "C init"
        super(C, self).__init__()

class D(B, C):
    def __init__(self):
        print "D init"
        super(D, self).__init__()

x = D()

该代码做了直观的事情，它打印：

D init
B init
C init
A init

但是，如果您注释掉 B 的 init 函数中对 super 的调用，则 A 和 C 的 init 函数都不会被调用。 这意味着 B 对 super 的调用在某种程度上知道 C 在整个类层次结构中的存在。 我知道 super 返回一个带有重载 get 运算符的代理对象，但是 D 的 init 定义中 super 返回的对象如何将 C 的存在传达给 B 的 init 定义中 super 返回的对象？ 后续调用 super 使用的信息是否存储在对象本身上？ 如果是这样，为什么不是 super 而不是 self.super？

编辑：Jekke 非常正确地指出它不是 self.super 因为 super 是类的属性，而不是类的实例。 从概念上讲这是有道理的，但实际上 super 也不是该类的属性！ 您可以在解释器中通过创建两个类 A 和 B（其中 B 继承自 A）并调用 dir(B) 来测试这一点。 它没有 super 或 __super__ 属性。

Answer 1

将您的代码更改为此，我认为它会解释一些事情（大概 super 正在查看 B 位于 __mro__ 中的位置？ ):

class A(object):
    def __init__(self):
        print "A init"
        print self.__class__.__mro__

class B(A):
    def __init__(self):
        print "B init"
        print self.__class__.__mro__
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print "C init"
        print self.__class__.__mro__
        super(C, self).__init__()

class D(B, C):
    def __init__(self):
        print "D init"
        print self.__class__.__mro__
        super(D, self).__init__()

x = D()

如果你运行它，你会看到：

D init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
B init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
C init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
A init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)

另外，值得一试 Python 的 Super 很漂亮，但你不能使用它。

Answer 2

我在下面提供了一些链接，它们比我希望的更详细、更准确地回答了您的问题。 不过，我也会用我自己的话回答你的问题，以节省你的时间。 我将把它放在点上 -

1. super 是一个内置函数，而不是一个属性。
2. Python 中的每个类型（类）都有一个__mro__ 属性，用于存储该特定实例的方法解析顺序。
3. 每次调用 super 的形式都是 super(type[, object-or-type])。 我们假设第二个属性目前是一个对象。
4. 在超级调用的起点，对象是派生类的类型（例如 DC）。
5. super 在指定为第一个参数的类（在本例中是 DC 之后的类）之后，在 MRO 中的类中查找匹配的方法（在您的情况下为 __init__）。
6. 当找到匹配的方法时（例如在 BC1 类中），就会调用它。
   （这个方法应该使用 super，所以我假设它确实如此 - 请参阅Python's super is nifty but can't be use - 下面的链接）
   然后，该方法会在对象类的 MRO 中搜索 BC1 右侧的下一个方法。
7. 重复冲洗直至找到并调用所有方法。

示例说明

 MRO: D,B,C,A,object  

1. super(D, self).__init__() 被调用。 isinstance(self, D) =>; True

2. 在 D 右侧的类中的 MRO 中搜索下一个方法。

   B.__init__ 找到并调用

---

3. B.__init__ 调用 super(B, self).__init__()。

   isinstance(self, B) =>; 错误
   isinstance(self, D) =>; True

4. 因此，MRO是相同的，但是搜索继续到B的右侧，即C，A，对象被一一搜索。 调用下一个找到的__init__。

5. 等等。

super的解释
http://www.python.org/download/releases/2.2 .3/descrintro/#合作
使用super时需要注意的事项
http://fuhm.net/super-harmful/
Python MRO 算法：
http://www.python.org/download/releases/2.3/mro/< /a>
super 的文档：
http://docs.python.org/library/functions.html
此页面的底部有一个关于超级的很好的部分：
http://docstore.mik.ua/ orelly/other/python/0596001886_pythonian-chp-5-sect-2.html

我希望这有助于澄清它。

Answer 3

只是猜测：

所有四个方法中的 self 都引用同一个对象，即 D 类的对象。
因此，在 B.__init__() 中，对 super(B,self) 的调用知道 self 的整个钻石血统，并且它具有从“after”B 获取方法。 在本例中，它是 C 类。

Answer 4

super() 知道完整类层次结构。 这就是 B 的 init 内部发生的事情：

>>> super(B, self)
<super: <class 'B'>, <D object>>

这解决了核心问题，

D 的 init 定义中 super 返回的对象如何将 C 的存在传达给 B 的 init 定义中 super 返回的对象？

也就是说，在 B 的 init 定义中，self 是 D 的一个实例，从而传达了 C 的存在。 例如，C 可以在 type(self).__mro__ 中找到。

Answer 5

Jacob 的回答展示了如何理解问题，batbrat 的回答展示了细节，hrr 的回答则开门见山。

他们没有从你的问题中涵盖（至少没有明确）的一件事是：

但是，如果注释掉 B 的 init 函数中对 super 的调用，则 A 和 C 的 init 函数都不会被调用。

要理解这一点，请将 Jacob 的代码更改为在 A 的 init 上打印堆栈，如下所示：

import traceback

class A(object):
    def __init__(self):
        print "A init"
        print self.__class__.__mro__
        traceback.print_stack()

class B(A):
    def __init__(self):
        print "B init"
        print self.__class__.__mro__
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print "C init"
        print self.__class__.__mro__
        super(C, self).__init__()

class D(B, C):
    def __init__(self):
        print "D init"
        print self.__class__.__mro__
        super(D, self).__init__()

x = D()

看到 B 的行 super(B, self).__init__( ) 实际上是调用 C.__init__()，因为 C 不是 B 的基类。

D init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
B init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
C init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
A init
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
  File "/tmp/jacobs.py", line 31, in <module>
    x = D()
  File "/tmp/jacobs.py", line 29, in __init__
    super(D, self).__init__()
  File "/tmp/jacobs.py", line 17, in __init__
    super(B, self).__init__()
  File "/tmp/jacobs.py", line 23, in __init__
    super(C, self).__init__()
  File "/tmp/jacobs.py", line 11, in __init__
    traceback.print_stack()

发生这种情况是因为 super (B, self) 没有“调用 B 的基类版本的 __init__”。 相反，它是在 self 的 上的 B 右侧的第一个类上调用 __init__ __mro__ 并且具有这样的属性。

因此，如果您在 B 的 init 函数中注释掉对 super 的调用，方法堆栈将在 B.__init__ 处停止，并且永远不会到达 C > 或 A。

总结一下：

• 无论引用哪个类，self始终是对实例的引用，并且其__mro__和__class__保持常量
• super () 查找查找 __mro__ 上当前类右侧的类的方法。 由于 __mro__ 保持不变，因此它会作为列表而不是树或图进行搜索。

关于最后一点，请注意，MRO 算法的全名是C3 超类线性化。 也就是说，它将该结构扁平化为列表。 当不同的 super() 调用发生时，它们会有效地迭代该列表。