Python之super()核心逻辑详解

相信在深入学习Python的OOP，尤其是继承逻辑时，多多少少都会接触到super()，并且大多数人也只是知道super()是用来调用超类指定方法并用于对超类进行功能拓展的，在python3.0以后，想使用超类的方法，直接无脑super().method即可，但是作者本着刨根问底的精神，经过研读官方文档并结合coding验证，在本文为大家详细剖析下super的核心工作机理。

一、super()的使用场景

super()一般用于需调用超类（父类）指定方法的场景，比如需对父类的初始化方法进行拓展（注意不是覆盖），如下代码：

class A:
    def __init__(self,name):
        self.name=name
class B(A):
    def __init__(self,name,age):
        self.age=age
        super().__init__(name)

并且在实际的OOP中，一般在对父类方法进行重载时，基本不会完全覆盖，而是拓展对应功能，所以super()在OOP中，会相对比较频繁的使用。

其实，因为在Python中，类本质是对象，类内定义的方法本质是类对象的属性，如果想调用父类中的方法，其实完全可以直接使用父类名.method的方法，不过此时需要显式传入实例对象，如下代码：

class A:
    def __init__(self,name):
        self.name=name

class B(A):
    def __init__(self,name,age):
        self.name=name
        A.__init__(self,age)

 但是这种调用方式，存在以下缺点：

1. 因为是直接使用的类名，故一定程度上相当于硬编码，因为如果B的父类发生变化了，那还要手动调整代码，增加代码的维护难度。
2. 如果在继承关系中，出现了钻石继承等，某父类方法会被调用两次甚至多次，这通常不是我们希望看到的。

所以，在python3.0以后，针对以上场景，强烈建议直接使用super()

二、super核心逻辑展开

super()完整的调用为super(type,obj or type)，共分为以下几种情况

1. 如果第二个参数为obj，则isinstanceof(obj,type)必须为真，也即type必须是obj的类或超类
2. 如果第二个参数为type，比如type1，则issubclass(type1, type)必须为真，也即type1必须是type的子类。

super(type,obj)返回的是一个super类的实例，即super其实是一个类，返回的实例包含以下两个关键信息

1. MRO：即type(obj)的MRO，假设obj的类为A，则对应MRO 即A.mro()
2. MRO中的类：即传入的type，该type必须在上面的MRO内

当super(type,obj)调用某方法或属性时，就会从MRO序列内，指定type之后，搜索该方法或属性。

在实际应用中，一般写成super(current_class,self)，可以简写为super()并且如果所有类调用父类方法时，均如此写，则可以完全保证是通过遍历固定self的MRO来执行方法，就会彻底避免父类方法被重复调用的问题。

三、代码验证

class A:
    def __init__(self):
        print('self为：{}，enter A'.format(self))
        print('leave A')
class B(A):
    def __init__(self):
        print('self为：{}，enter B'.format(self))
        super(B,self).__init__()
        print('leave B')
class C(A):
    def __init__(self):
        print('self为：{}，enter C'.format(self))
        super(C,self).__init__()
        print('leave C')
class D(B,C):
    def __init__(self):
        print('self为：{}，enter D'.format(self))
        super(D,self).__init__()
        print('leave D')    
class E(D,C):
    def __init__(self):
        print('self为：{}，enter E'.format(self))
        super(E,self).__init__()
        print('leave E')   
print('E的MRO为：{}'.format(E.mro()))        
e=E()

#输出如下：
E的MRO为：[<class '__main__.E'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
self为：<__main__.E object at 0x1150a05b0>，enter E
self为：<__main__.E object at 0x1150a05b0>，enter D
self为：<__main__.E object at 0x1150a05b0>，enter B
self为：<__main__.E object at 0x1150a05b0>，enter C
self为：<__main__.E object at 0x1150a05b0>，enter A
leave A
leave C
leave B
leave D
leave E

 代码解析如下：

1. 因为以上几个类，在调用父类方法时，均使用的super()，且传入的self都是e，故执行搜索时均用的一个mro，即类E的mro。
2. 类E的mro为，E.mro()，对应搜索树的顺序为E＞D＞B＞C＞A
3. 分布运行解析如下：
   1. 首先在E的初始化时，因为传入的是E，所以会沿着E的MRO并找在E后面的类作为父类去调用，此时是D
   2. 再调用D的初始化函数时，因为此时传入的type为D，但self还是e，故MRO不变，但是会从D后面找，命中B
   3. 再调用B的初始化函数，因为此时传入的type是B，但self还是e，故MRO不变，但是会从B后面招，命中A
   4. 后面就是堆栈的反向运行了，不再赘述。

四、总结

可以看出，super(type,self)本质就是定义以怎样的顺序和规则来检索和决定调用哪个父类的方法。具体规则即，从self对应的类的MRO中，找到排在type类后面的第一个类作为父类，并调用该父类指定的方法。

比如，如果self对应类为A，A的MRO顺序为A＞B＞C＞D＞E＞F，则：

1. 如果为super(A,self)，则此时会命中B作为父类并调用其对应方法（如果没有则肯定略过）
2. 如果为super(D,self),则此时会命中E作为父类并调用其对应方法
3. 如果为super(C,A)，则此时会命中D作为父类并调用其对应方法

不过如果您已经全面转战python3了，建议日常使用中，直接使用super()即可，这种调用方式会自动将当前所在的类和对应的self传入。