通过__init __（）方法了解Python super（）

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()

#1 楼

super()让您避免显式引用基类，这可能很好。但是主要优势来自多重继承，其中可以发生各种有趣的事情。

请注意关于super的标准文档。

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

#2 楼

我想了解super()



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

在Python 3中，我们可以这样称呼它：

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

在Python 2中，我们需要像这样使用它：

super(ChildB, self).__init__()

没有超级，使用多重继承的能力就会受到限制：

Base.__init__(self) # Avoid this.

我在下面进一步解释。


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

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

class ChildB(Base):
    def __init__(self):
        super(ChildB, self).__init__()
        # super().__init__() # you can call super like this in Python 3!

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

我在一个规范问题（如何在Python中使用“ super”？）的答案中说明了这种差异。

如果Python没有super


，这里的代码实际上与super等效（在C中如何实现，减去一些检查和后备行为，并转换为Python）：

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()             # Get the Method Resolution Order.
        check_next = mro.index(ChildB) + 1 # Start looking 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对象，则必须在任何地方编写此手动代码（或重新创建它），以确保我们在“方法解析顺序”中调用正确的下一个方法！

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

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

因为它要求MRO的第一个参数，所以不可能将super与静态方法一起使用。

其他答案的批评：


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(ChildB, self).__init__()

现在记住，ChildB使用超级，ChildA不使用：

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

和UserA不会调用UserDependency方法：

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

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

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

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

对另一个答案的批评

在任何情况下，您都不应执行以下建议，这是另一个答案所建议的，因为当您继承ChildB的子类时肯定会出错：

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

（这个答案并不聪明，也不是特别有趣，但是尽管在评论中有直接批评和超过17次否决票，回答者仍然坚持建议，直到善良的编辑者解决了他的问题。）

说明：使用self.__class__代替super()中的类名会破坏MRO并可能导致递归。 super让我们在MRO中查找下一个父类（请参阅此答案的第一部分）以获取子类。如果您告诉super我们在子实例的方法中，它将在行中查找下一个方法（可能是这个方法），从而导致递归，可能会导致逻辑故障（在回答者的示例中，确实如此），或者当RuntimeError超出了递归深度。

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

#3 楼

需要注意的是，在Python 3.0+中，您可以使用

super().__init__()

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

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

但是，这中断从您的类继承的任何类的super的调用，其中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，这样我就可以重新实现其他方法。

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

#4 楼

超级没有副作用

Base = ChildB

Base()

按预期工作

Base = ChildA

Base()

进入无限递归。

#5 楼

刚开始……使用Python 2.7，并且我相信自从在版本2.2中引入super()以来，如果其中一个父类继承自最终继承super()（新式类）的类，则您只能调用object。 />
就python 2.7代码而言，我个人将继续使用BaseClassName.__init__(self, args)，直到我真正获得使用super()的好处为止。

#6 楼

真的没有。 super()查看MRO中的下一个类（方法解析顺序，使用cls.__mro__访问）以调用方法。只需调用基本__init__即可调用基本__init__。碰巧的是，MRO只有一项-基础。因此，您实际上确实在做同样的事情，但使用super()的方式更好（特别是如果以后要进行多重继承的话）。

#7 楼

主要区别是ChildA.__init__将无条件调用Base.__init__，而ChildB.__init__将在__init__祖先行中的ChildB祖先类别中任意调用self
（可能与您的期望不同）。
如果您添加一个使用多重继承的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的父级。现在，如果super(ChildB, self)是Mixin实例，则self将指向ChildC。
您已在Mixin和ChildB之间插入了Base。而且，您可以通过super()来利用它，因此，如果您将类设计为可以在协作多重继承方案中使用，请使用super，因为您实际上并不知道谁将成为祖先在运行时。
超级视频和pycon 2015随附视频很好地解释了这一点。