谈谈python super

python中的super是用来调用父类的方法吗？

答：不算错，但是不准确。某些情况下是这样的，某些情况下又不是。

用一句话说明super的作用是什么？

答：简单来说就是提供一个 MRO 以及一个 MRO 中的类 C ， super() 将返回从 MRO 中 查找C类之后的第一个类的实例。

通过源代码更容易理解

def super(cls, inst):
    mro = inst.__class__.mro()
    return mro[mro.index(cls) + 1]

inst提供了一个MRO，cls提供了MRO中的类C，而super返回的就是从inst提供的MRO中查找，cls这个类后面一个类的实例。

注：不光可以通过inst提供MRO，也可以通过类提供MRO。那么super的形式就是super(A, B)，A和B都是类，而不是实例。意义也是一样。

B提供了一个MRO，A提供了MRO中的类C，而super返回的就是从B提供的MRO中查找，A这个类后面一个类的实例。

举个实际例子：

这里环境是python3

class Root(object):
    def __init__(self):
        print("this is Root")

class B(Root):
    def __init__(self):
        print("enter B")
        # print(self)  # this will print <__main__.D object at 0x...>
        super(B, self).__init__()
        print("leave B")

class C(Root):
    def __init__(self):
        print("enter C")
        super(C, self).__init__()
        print("leave C")

class D(B, C):
    pass

d = D()
print(d.__class__.__mro__)

d的MRO：

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.Root'>, <type 'object'>)

1. D类实例化时，执行__init__()函数，因为 D 没有定义 init，所以会在d的 MRO 中找下一个类，去查看它有没有定义 init，也就是去调用 B 的 init。
2. 调用B的__init__，打印enter B，调用super(B, self).init()，根据我们刚刚讲的super的定义，其实他并不是查找父类的实例，而是查找self这个实例（这个实例是D的实例d，而不是B类的实例）的MRO中，B类之后的下一个类的实例，这里就是C类，所以会打印enter C，然后调用super(C, self).init()方法。
3. 同理，调用super(C, self).init()方法，是根据self这个实例（这个实例是D的实例d，而不是B类的实例）的MRO中，C类之后的下一个类的实例，就是Root类的实例。所以打印this is Root。然后打印leave C， leave B。

备注：
super 是个类
当我们调用 super() 的时候，实际上是实例化了一个 super 类。你没看错， super 是个类，既不是关键字也不是函数等其他数据结构:

>>> class A:pass
... 
>>> s=super(A)
>>> type(s)
<class 'super'>
>>> isinstance(s,A)
False
>>> isinstance(s,super)
True
>>> 

来看一下super继承的列子

class A:
    def __init__(self):
        self.n = 2

    def add(self, m):
        # 第四步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @A.add'.format(self))
        self.n += m
        # d.n == 7


class B(A):
    def __init__(self):
        self.n = 3

    def add(self, m):
        # 第二步
        # 来自 D.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @B.add'.format(self))
        # 等价于 suepr(B, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 B 之后的 [C, A, object] 中查找 add 方法
        super().add(m)

        # 第六步
        # d.n = 11
        self.n += 3
        # d.n = 14

class C(A):
    def __init__(self):
        self.n = 4

    def add(self, m):
        # 第三步
        # 来自 B.add 中的 super
        # self == d, self.n == d.n == 5
        print('self is {0} @C.add'.format(self))
        # 等价于 suepr(C, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 C 之后的 [A, object] 中查找 add 方法
        super().add(m)

        # 第五步
        # d.n = 7
        self.n += 4
        # d.n = 11


class D(B, C):
    def __init__(self):
        self.n = 5

    def add(self, m):
        # 第一步
        print('self is {0} @D.add'.format(self))
        # 等价于 super(D, self).add(m)
        # self 的 MRO 是 [D, B, C, A, object]
        # 从 D 之后的 [B, C, A, object] 中查找 add 方法
        super().add(m)

        # 第七步
        # d.n = 14
        self.n += 5
        # self.n = 19

d = D()
d.add(2)
print(d.n)

结果是：

self is <__main__.D object at 0x10ce10e48> @D.add
self is <__main__.D object at 0x10ce10e48> @B.add
self is <__main__.D object at 0x10ce10e48> @C.add
self is <__main__.D object at 0x10ce10e48> @A.add
19

我们看到并不是按照继承的顺序打印的，不是按照D继承B,C，B和C有继承A，D,B,A,C,A。

参考：
https://mozillazg.com/2016/12/python-super-is-not-as-simple-as-you-thought.html
https://laike9m.com/blog/li-jie-python-super,70/