一、前言（所有内容都基于最开始的代码）

class A:def __init__(self):print('A')
class B(A):def __init__(self):print('B')if __main__ == '__main__':b = B() # B

但在某些情况下我们希望在运行时能够直接调用其父类的方法，怎么做呢？

class A:def __init__(self):print('A')class B(A):def __init__(self):super(B,self).__init__() # super().__init__()print('B')if __main__ == '__main__':b = B() # B # A

在python2中是super(B,self).__init__()；在python3中简化为super().__init__()。

二、既然重写对象B的构造函数，那为什么还要去调用super？

拿多线程举例，我们定义一个自己的线程类MyThread，然后去继承Thread类。

from  threading import Thread
class MyThread(Thread):def __init(self,name,user):self.user = user# self.name = name (不需要)super().__init__(name=name)

在自定义的MyThread类中，先定义一个初始化函数，假设给它传递name(线程名称）和user(执行的用户）两个参数。此时可以不使用self.name = name。

因为在源码中的Thread类中已经实现了__init__方法，在该方法中有许多的参数，其中就有name参数，并且在该方法中也实现了许多的逻辑。

实际上让自定义的MyThread类直接调用父类Thread即可，等于把构造函数交给了父类去实例化，这样就可以重用父类中的代码(方法，逻辑)，所以在某些情况下，super函数还是需要调用的。

• Thread类源码的__init__部分 (不用细看，注意结构即可)

class Thread:"""A class that represents a thread of control.This class can be safely subclassed in a limited fashion. There are two waysto specify the activity: by passing a callable object to the constructor, orby overriding the run() method in a subclass."""def __init__(self, group=None, target=None, name=None,args=(), kwargs=None, *, daemon=None):"""This constructor should always be called with keyword arguments. Arguments are:*group* should be None; reserved for future extension when a ThreadGroupclass is implemented.*target* is the callable object to be invoked by the run()method. Defaults to None, meaning nothing is called.*name* is the thread name. By default, a unique name is constructed ofthe form "Thread-N" where N is a small decimal number.*args* is the argument tuple for the target invocation. Defaults to ().*kwargs* is a dictionary of keyword arguments for the targetinvocation. Defaults to {}.If a subclass overrides the constructor, it must make sure to invokethe base class constructor (Thread.__init__()) before doing anythingelse to the thread."""assert group is None, "group argument must be None for now"if kwargs is None:kwargs = {}self._target = targetself._name = str(name or _newname())self._args = argsself._kwargs = kwargsif daemon is not None:self._daemonic = daemonelse:self._daemonic = current_thread().daemonself._ident = Noneself._tstate_lock = Noneself._started = Event()self._is_stopped = Falseself._initialized = True# sys.stderr is not stored in the class like# sys.exc_info since it can be changed between instancesself._stderr = _sys.stderr# For debugging and _after_fork()_dangling.add(self)    

三、super函数的执行顺序是什么样的？

super函数是调用父类的构造函数(方法)，这句话其实并不是完全正确。（这涉及到MRO算法）

举个简单的例子，定义4个类，B和C都继承A，而D继承B和C。如果在D类中使用super函数，而D类的父类又有两个(B和C)，因为B在C之前，所以优先调用B中的构造函数。

而B中也有super函数，那是不是就应该去打印A了？ 从运行结果可以看出答案是NO。

super函数不仅仅是调用父类函数，而且是按MRO算法继承链的顺序去进行调用

class A:def __init__(self):print('A')
class B(A):def __init__(self):print('B')super().__init__() class C(A):def __init__(self):print('C')super().__init__() class D(B,C):def __init__(self):print('D')   super(D,self).__init__() if __main__ == '__main__':d = D() #	D #	B	#	A	#	C	

使用__mro__就可以看到继承链中的顺序——首先D然后B，再C，再A。

print(D.__mro__)
# (<class ‘__main__.D’>,<class ‘__main__.B’>,<class ‘__main__.C’>,<class ‘__main__.A’>,<class ‘object’>)