理解 Python super() 和 __init__() 方法

Question

为什么使用super()？

使用 Base.__init__ 和 super().__init__ 之间有区别吗？

class Base(object):
    def __init__(self):
        print "Base created"
        
class ChildA(Base):
    def __init__(self):
        Base.__init__(self)
        
class ChildB(Base):
    def __init__(self):
        super(ChildB, self).__init__()
        
ChildA() 
ChildB()

Answer 1

super() 可以让您避免显式引用基类，这很好。 但主要优点是多重继承，其中有各种有趣的东西可以发生。 如果您还没有看过有关 super 的标准文档，请参阅。

请注意，Python 3.0 中的语法已更改：您可以只说 super().__init__() 而不是 super(ChildB, self).__init__() IMO 更好一些。 标准文档还参考了 使用 super() 的指南 这是非常有解释性的。

Answer 2

我试图理解super()

我们使用 super 的原因是，可能使用协作多重继承的子类将调用正确的下一个父类函数方法解析顺序 (MRO)。

在Python 3中，我们可以这样调用它：

class ChildB(Base):
    def __init__(self):
        super().__init__()

在Python 2中，我们需要使用定义类的名称和self来调用super，但我们会避免从现在开始，因为它是多余的，更慢（由于名称查找），而且更冗长（所以如果你还没有更新你的Python，请更新它！）：如果

        super(ChildB, self).__init__()

没有 super，你使用多重继承的能力就会受到限制，因为你很难- 转接下一位家长的电话：

        Base.__init__(self) # Avoid this.

我在下面进一步解释。

“这段代码实际上有什么区别？：”

class ChildA(Base):
    def __init__(self):
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        super().__init__()

这段代码的主要区别在于，在 ChildB 中，您在 __init__ 中使用 super 获得了一个间接层，它使用定义它的类来确定要在 MRO 中查找的下一个类的 __init__。

我在规范问题“How to use 'super' in Python?”的答案中说明了这种差异，该问题演示了依赖注入和协作多重继承。

如果 Python 没有 super

下面的代码实际上与 super 非常接近（它是如何在 C 中实现的，减去一些检查和后备行为，然后翻译成 Python）

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()
        check_next = mro.index(ChildB) + 1 # next after *this* class.
        while check_next < len(mro):
            next_class = mro[check_next]
            if '__init__' in next_class.__dict__:
                next_class.__init__(self)
                break
            check_next += 1

：有点像原生 Python：

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()
        for next_class in mro[mro.index(ChildB) + 1:]: # slice to end
            if hasattr(next_class, '__init__'):
                next_class.__init__(self)
                break

如果我们没有 super 对象，我们必须在任何地方编写此手动代码（或重新创建它！）以确保我们调用正确的 next 方法方法解析顺序！

super 在 Python 3 中如何做到这一点，而无需明确告知调用它的方法是哪个类和实例？

它获取调用堆栈帧，并找到该类（隐式存储为本地自由变量，__class__，使调用函数成为该类的闭包）和该函数的第一个参数，该参数应该是通知它使用哪种方法解析顺序 (MRO) 的实例或类。

由于它需要 MRO 的第一个参数，因此 将 super 与静态方法一起使用是不可能的无法访问调用它们的类的 MRO。

对其他答案的批评：

super() 让您可以避免显式引用基类，这很好。 。 但主要优点是多重继承，可以发生各种有趣的事情。 如果您还没有看过 super 的标准文档，请参阅。

它相当简单，并没有告诉我们太多信息，但 super 的要点并不是避免编写父类。 重点是确保调用方法解析顺序 (MRO) 中的下一个方法。 这在多重继承中变得很重要。

我在这里解释一下。

class Base(object):
    def __init__(self):
        print("Base init'ed")

class ChildA(Base):
    def __init__(self):
        print("ChildA init'ed")
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        print("ChildB init'ed")
        super().__init__()

让我们创建一个要在 Child 之后调用的依赖项：

class UserDependency(Base):
    def __init__(self):
        print("UserDependency init'ed")
        super().__init__()

现在记住，ChildB 使用 super，ChildA 不使用：

class UserA(ChildA, UserDependency):
    def __init__(self):
        print("UserA init'ed")
        super().__init__()

class UserB(ChildB, UserDependency):
    def __init__(self):
        print("UserB init'ed")
        super().__init__()

而 UserA 则使用 super不调用 UserDependency 方法：

>>> UserA()
UserA init'ed
ChildA init'ed
Base init'ed
<__main__.UserA object at 0x0000000003403BA8>

但 UserB 实际上调用 UserDependency 因为 ChildB 调用 super：

>>> UserB()
UserB init'ed
ChildB init'ed
UserDependency init'ed
Base init'ed
<__main__.UserB object at 0x0000000003403438>

对另一个答案的批评

在任何情况下都不应该这样做下面是另一个答案所暗示的，因为当你对 ChildB 进行子类化时，你肯定会遇到错误：

super(self.__class__, self).__init__()  # DON'T DO THIS! EVER.

_{（这个答案并不聪明或特别有趣，但尽管评论中存在直接批评和超过 17 票反对，但回答者仍然坚持直到一位好心的编辑解决了他的问题。）} 说明

：使用 self.__class__ 作为在 super() 中按名称显式传递类的替代品会导致递归。 super 让我们在 MRO 中查找子类的下一个父类（请参阅本答案的第一部分）。 如果我们告诉 super 我们在子方法中，它就会查找行中的下一个方法（可能是我们调用它的同一个方法），导致递归，导致逻辑失败（如在回答者的示例中）或超过最大递归深度时的 RuntimeError 。

class Polygon(object):
    def __init__(self, id):
        self.id = id

class Rectangle(Polygon):
    def __init__(self, id, width, height):
        super(self.__class__, self).__init__(id)
        self.shape = (width, height)

class Square(Rectangle):
    pass

>>> Square('a', 10, 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: __init__() missing 2 required positional arguments: 'width' and 'height'

幸运的是，Python 3 的新的不带参数的 super() 调用方法允许我们回避这个问题。

Answer 3

值得注意的是，在 Python 3.0+ 中，您可以使用

super().__init__()

来进行调用，这很简洁，并且不需要您显式引用父类或类名，这很方便。 我只想补充一点，对于 Python 2.7 或更低版本，有些人通过编写 self.__class__ 而不是类名来实现名称不敏感的行为，即，但是

super(self.__class__, self).__init__()  # DON'T DO THIS!

，这会中断对 super< 的调用/code> 对于从您的类继承的任何类，其中 self.__class__ 可以返回子类。 例如：

class Polygon(object):
    def __init__(self, id):
        self.id = id

class Rectangle(Polygon):
    def __init__(self, id, width, height):
        super(self.__class__, self).__init__(id)
        self.shape = (width, height)

class Square(Rectangle):
    pass

这里我有一个类Square，它是Rectangle的子类。 假设我不想为 Square 编写单独的构造函数，因为 Rectangle 的构造函数已经足够好了，但无论出于何种原因，我想实现 Square，以便可以重新实现其他一些方法。

当我使用 mSquare = Square('a', 10,10) 创建 Square 时，Python 会调用 Rectangle 的构造函数，因为我还没有' t 给 Square 它自己的构造函数。 但是，在 Rectangle 的构造函数中，调用 super(self.__class__,self) 将返回 mSquare 的超类，因此它再次调用 Rectangle 的构造函数。 正如 @S_C 所提到的，这就是无限循环发生的方式。 在这种情况下，当我运行 super(...).__init__() 时，我正在调用 Rectangle 的构造函数，但由于我没有给它任何参数，所以我会得到一个错误。

Answer 4

Super 没有副作用

Base = ChildB

Base()

，按预期

Base = ChildA

Base()

进入无限递归。

Answer 5

请注意......使用Python 2.7，我相信自从在版本2.2中引入 super() 以来，你只能调用 super() 如果父级之一继承自最终继承 object 的类（ 新样式类）。

就我个人而言，对于 python 2.7 代码，我将继续使用 BaseClassName.__init__(self, args) 直到我真正获得使用 super() 的优势。

Answer 6

确实没有。 super() 查看 MRO 中的下一个类（方法解析顺序，通过 cls.__mro__ 访问）来调用方法。 只需调用基 __init__ 即可调用基 __init__。 碰巧的是，MRO 只有一件物品——底座。 因此，您确实在做完全相同的事情，但使用 super() 的方式更好（特别是如果您稍后进入多重继承）。

Answer 7

主要区别在于 ChildA.__init__ 将无条件调用 Base.__init__ 而 ChildB.__init__ 将调用 __init__ 无论哪个类恰好是 self 祖先行中的 ChildB 祖先
（这可能与您的期望不同）。

如果您添加使用多重继承的 ClassC：

class Mixin(Base):
  def __init__(self):
    print "Mixin stuff"
    super(Mixin, self).__init__()

class ChildC(ChildB, Mixin):  # Mixin is now between ChildB and Base
  pass

ChildC()
help(ChildC) # shows that the Method Resolution Order is ChildC->ChildB->Mixin->Base

则 Base 不再是 ChildB 的父级>ChildC 实例。 现在，如果 self 是 ChildC 实例，则 super(ChildB, self) 将指向 Mixin。

您已在 ChildB 和 Base 之间插入 Mixin。 您可以通过 super() 来利用它。

因此，如果您设计的类可以在协作多重继承场景中使用，那么您可以使用 super，因为您在运行时并不真正知道谁将成为祖先。

超级被视为超级帖子和pycon 2015 随附视频很好地解释了这一点。