python(二)基础之mro与super

python的mro

Python的MRO即Method Resolution Order（方法解析顺序），即在调用方法时，会对当前类以及所有的基类进行一个搜索，以确定该方法之所在，而这个搜索的顺序就是MRO。

本地优先级:指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类。

单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里，也必须满足这个顺序。

总的来说，一个类的 MRO 列表就是合并所有父类的 MRO 列表，并遵循以下三条原则：

• 子类永远在父类前面

• 如果有多个父类，会根据它们在列表中的顺序被检查

• 如果对下一个类存在两个合法的选择，选择第一个父类

下面用图解的形式来表现三条原则并计算出MRO（只是说这种方式可以手算出MRO，而不是说这是C3算法的具体实现方式）：

class F:
    pass
 
class E:
    pass
 
class D:
    pass
 
class B(D,E):
    pass
 
class C(D,F):
    pass
 
class A(B,C):
    pass

然后我们构建一个继承顺序图，即让子类用箭头指向父类，遇到多继承则按代码中继承列表的顺序从左往右写。如果有多个子类继承了同一个父类，那么这个父类则放在它能够出现的所有位置中最左的位置（注意：如下图中那样，D既可以放在B的左上方，又可以放在C的左上方，这种情况下，我们选择放在B的左上方，因为这样D在其所在层更加靠左），然后让这些子类指向它，就像下图中类D那样。

接下来，我们就开始算出相应的MRO。即需遵循图里面的广度优先原则进行遍历（在广度优先原则的前提下又优先遍历左边的）：

首先寻找整个图中入度为0的，也就是A，那么A也就成为MRO中的第一个。

然后我们去掉图中的A节点以及与A相关的连线，再寻找入度为0的点，这时有B和C两个节点，我们选择最左边的点即B。选完左边的B点后，再选右边的C点，这样B和C也就跟着进入了MRO序列，现在MRO序列为{A,B,C}。（注意每次层次遍历一定要把那一层选完才能选下一层，不能在没有选C之前跳到选E）

然后去掉B和C以及与它们相关的连线，这时候入度为0的也就是D、E、F了，依次选择，使D、E、F进入MRO序列。

最后也就使得object进入MRO序列。

以上的MRO序列也就是{ABCDEFobject}

使用 类名.mro()可以查阅其MRO表：

super()，为什么要用super()

让代码维护更加简单

Python是一门面向对象的语言，定义类时经常用到继承的概念，既然用到继承就少不得要在子类中引用父类的属性，我们可以通过“父类名.属性名”的方式来调用，代码如下：

class A:

	def fun(self):
        print('A.fun')


class B(A):

    def fun(self):
        A.fun(self)
        print('B.fun')

一旦A类类名改了，我们就要分别到那几十上百个子类中修改，不但要改继承时用到的A类名，调用A类方法时用到的A类名也要改，繁琐的很，用super就好多了：

class A:

    def fun(self):
        print('A.fun')

  

class B(A):

    def fun(self):
        super().fun()
        print('B.fun')

解决多继承带来的重复调用（菱形继承）、查找顺序（MRO）问题

Python是的继承机制是多继承，还是用这种方法来调用父类属性就会就回带来许多问题。假如有A、B、C、D这4个类，继承关系如下，我们要在各子类方法中显式调用父类的方法（姑且不考虑是否符合需求）：

class A:

    def fun(self):
        print('A.fun')

  
class B(A):

    def fun(self):
        A.fun(self)
        print('B.fun')

  
class C(A):

    def fun(self):
        A.fun(self)
        print('C.fun')

  

class D(B , C):

    def fun(self):
        B.fun(self)
        C.fun(self)
        print('D.fun')

  
D().fun()

输出结果为

A.fun

B.fun

A.fun

C.fun

D.fun

A类被实例化了两次。这就是多继承带来的重复调用（菱形继承）的问题。使用super可以很好的解决这一问题：

class A:

    def fun(self):
        print('A.fun')

  

class B(A):

    def fun(self):
        super(B , self).fun()
        print('B.fun')

  

class C(A):

    def fun(self):
        super(C , self).fun()
        print('C.fun')

  

class D(B , C):

    def fun(self):
        super(D , self).fun()
        print('D.fun')

  

D().fun()

输出结果为：

A.fun

C.fun

B.fun

D.fun

怎么用super()

super是一个类（不是方法），实例化之后得到的是一个代理的对象，而不是得到了父类，并且我们使用这个代理对象来调用父类或者兄弟类的方法。使用格式如下：

super([type[, object-or-type]])

将这个格式展开来就有一下几种传参方式：

super()

super(type , obj)

super(type_1 , type_2)

注意：可没有super(type)这种方式

本文转载自：
https://www.py.cn/jishu/jichu/20391.html
https://blog.csdn.net/come_from_pluto