super（）允许您避免显式引用基类，这可能很好。但主要的优势来自多重继承，在这里可以发生各种有趣的事情。如果还没有，请查看super上的标准文档。

注意，Python 3.0中的语法发生了变化：您可以只说super（）__init__（）而不是super（ChildB，self）__init__（），它比IMO好得多。标准文档还引用了一个使用super（）的指南，这是非常解释性的。

真的没有。super（）查看MRO中的下一个类（方法解析顺序，使用cls.__MRO_访问）以调用方法。只需调用基__init__即可调用基__init __。碰巧，MRO只有一个项目——基础。因此，您确实在做完全相同的事情，但使用super（）的方式更好（特别是如果您稍后进入多重继承）。

super（）允许您避免显式引用基类，这可能很好。但主要的优势来自多重继承，在这里可以发生各种有趣的事情。如果还没有，请查看super上的标准文档。

注意，Python 3.0中的语法发生了变化：您可以只说super（）__init__（）而不是super（ChildB，self）__init__（），它比IMO好得多。标准文档还引用了一个使用super（）的指南，这是非常解释性的。

我正在努力理解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__。

我在经典问题“如何在Python中使用“super”？”的回答中说明了这一区别？，它展示了依赖注入和协作多重继承。

如果Python没有超级

这里的代码实际上与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如何在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不调用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'

幸运的是，Python3新的super（）调用方法没有参数，这让我们可以避开这个问题。

已经注意到，在Python 3.0+中，您可以使用

super().__init__()

这是一种简洁的方法，不需要显式引用父类OR类名，这很方便。我只想补充一点，对于Python 2.7或更低版本，有些人通过编写self来实现不区分名称的行为__class__而不是类名，即。

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

然而，这中断了对从类继承的任何类的调用，其中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，它是矩形的子类。假设我不想为Square编写单独的构造函数，因为Rectangle的构造函数已经足够好了，但无论出于什么原因，我都希望实现一个Square，这样我就可以重新实现一些其他方法。

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

只是抬头。。。对于Python 2.7，我相信自从super（）在2.2版中引入以来，只有当父类之一继承了最终继承对象的类（新型类）时，才能调用super（。

就个人而言，对于python 2.7代码，我将继续使用BaseClassName__init__（self，args），直到我真正获得使用super（）的优势。