比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

Python大神必须掌握的技能:多继承、super与MRO算法

Python大神必须掌握的技能:多继承、super与MRO算法

本文主要以Python3.x为例讲解Python多继承、super以及MRO算法。

1. Python中的继承

 

任何面向对象编程语言都会支持继承,Python也不例外。但Python语言却是少数几个支持多继承的面向对象编程语言(另一个著名的支持多继承的编程语言是C++)。本文将深入阐述Python多继承中经常用到的super,并且会展示一个你所不知道的super。

相信继承的概念大家一定不会陌生。当类B从类A继承后,B类就会继承A类的所有非私有成员(由于Python没有私有成员的概念,所以B类就会继承A类的所有成员)。但有时需要在B类中直接访问A类的成员,也就是子类需要调用父类的成员,在这种情况下,有如下两种方法可以解决:

1. 在子类中直接通过父类名访问父类中的成员

2. 在子类中通过super访问父类中的成员

现在先说第一种方法。

inhert.py

复制代码
class A:
    def __init__(self):
        print('Start A')
        print('End A')
    def greet(self, name):
        return f'hello {name}'

class B(A):
    def __init__(self):
        print('Start B')
        # 直接通过父类名调用父类的构造方法
        A.__init__(self)
        # 调用父类的greet方法 
        print(A.greet(self,'Bill'))
        # 调用当前类的greet方法
        print(self.greet('Bill'))
        print('End B')
    # 覆盖父类的greet方法
    def greet(self,name):
        return f'你好 {name}'
B()  # 创建B类的实例
复制代码

 

这段代码的运行结果如图1所示。

图1

在B类中,通过A. __init__(self)和A.greet(self,’Bill’)调用了父类(A类)的成员。在Python2.2之前,Python类只支持这种访问父类成员的方式。尽管这种方式非常直接,但缺点是如果父类名改变,这就意味着所有使用父类名的子类都需要改变,如果某个类的子类非常多,就可能会增加非常多的代码维护工作量。所以从Python2.2开始,又增加了一种新的访问父类的方式,这就是本文主要介绍的super。当然,旧的方式也同样支持。

2.引入super

为了尽可能避免在子类中直接使用父类的名字,从Python2.2开始支持super。super并不是一个函数或方法,而是一个类。super类的构造方法需要两个参数:type和instance。其中type就是类型,例如,A、B等,instance就是B类或其子类的实例。至于为什么要传递这个实例。后面会详细介绍,总之,该实例与本文的另外一个重点MRO算法有关。

先看下面的代码:

super1.py

复制代码
class A:
    def __init__(self):
        print('Start A')
        print('End A')
    def greet(self, name):
        return f'hello {name}'


class B(A):
    def __init__(self):
        print('Start B')
        # 通过super调用父类的构造方法
        super(B, self).__init__()
        # 通过super调用父类的成员方法
        print(super(B, self).greet('Bill'))
        print(self.greet('Bill'))
        print('End B')
    def greet(self,name):
        return f'你好 {name}'


B()
复制代码

执行这段代码,会输出与图1完全相同的效果。在B类中并没有直接使用A类的名字,而是使用了super。如果A类的名字变化了,只需要修改B类的父类即可,并不需要修改B类内部的代码,这样将大大减少维护B类的工作量。

可能有的同学会问,super的第2个参数的值为什么是self呢?我们都知道,在Python中,self表示类本身的实例,那么为什么不是B()或是A()呢?首先这个实例要求必须是B或B的子类的实例,所以A()以及其他不相关类的实例自然就排除在外,那么B()为什么不行呢?其实从语义上来说,B()没问题,但问题是这样将产生无限递归的后果。也就是在B类的构造方法又调用了B的构造方法(B()表示调用B类的构造方法),而且没有终止条件。所以这么做的后果就是栈溢出。

尽管不能在B类构造方法内部直接创建B类的实例,但却可以在外部创建好B类的实例或B类子类的实例,然后通过B类构造方法将该实例传入,看下面的代码。
super2.py

复制代码
class A:
    def __init__(self):
        print('Start A')
        print('End A')
class B(A):
    def __init__(self,c):
        print('Start B')
        # 将外部创建的C类的实例传入super类的构造方法
        super(B, c).__init__()
        print('End B')
class C(B):
    def __init__(self, c):
        super(C,self).__init__(c)
c = C(None)
b = B(None)
B(b)
B(c)
复制代码

这段代码在创建B实例之前,先创建了一个C类的实例以及一个传入None的B实例。而在B类的构造方法中多了一个参数,用于传入这个外部实例,并将这个外部实例作为super类构造方法的第2个参数传入。由于在创建C类和B类实例时传入了None,所以super类构造方法的第2个参数值也是None。这样回就会导致super(B,c)无法调用父类(A类)的构造方法,这就相当于一个空操作(什么都不会做),至于为什么会这样,后面讲MRO算法时就会一清二楚。

3. 多继承,找到亲爹好难啊

其实如果Python不支持多继承,一切都好说,一切都好理解。但问题是,Python支持多继承,这就使得继承的问题变得扑朔迷离,尤其是对初学者,更是一头雾水。对于多继承来说,一个重要的问题就是:在多个父类拥有同名成员的情况下,在子类中访问该成员,到底是调用哪一个父类的成员呢?  毫无疑问,只有一个父类会为子类提供这个成员,也就是子类的亲爹。至于其他拥有同名成员的父类,与该子类毫无关系,尽管名义上都拥有该成员。

现在用一个最简单的多继承程序来说明问题:

super3.py

复制代码
class X1:
    def __init__(self):
        print('Start X1')
        print('End X1')


class X2:
    def __init__(self,c):
        print('Start X2')
        print('End X2')
class A(X1,X2):
    def __init__(self):
        print('Start A')
        super(A,self).__init__()
        print('End A')
A()
复制代码

在这段代码中,X1和X2都是A的父类,而在A类的构造方法中使用super(A,self).__init__()调用了父类的构造方法。任何Python类的构造方法可能都是同名的,都是__init__。如果A类只有一个父类,一切都好说。但如果A类有2个或2个以上的父类,那么到底调用哪一个父类的构造方法呢?
读者可以先运行这段代码,会看到输出如下的内容:

Start A
Start X1
End X1
End A

 

很明显,A调用了X1的构造方法。读者可以再做一个实验,将X1和X2的顺序调换一下,变成A(X2,X1),这时会输出如下的内容:
Start A
Start X2
End X2
End A

 

很明显,这时A调用了X2的构造方法。从观察运行结果可以找出一点规律,就是使用super(A,self),会调用A类的父类列表中第1个父类的成员(本例是X1)。那么结果真是这样吗?

下面再看一个更复杂的多继承案例:

super4.py

复制代码
class X1:
    def __init__(self):
        print('Start X1')
        print('End X1')
class X2:
    def __init__(self):
        print('Start X2')
        print('End X2')
class A(X1,X2):
    def __init__(self):
        print('Start A')
        super(A,self).__init__()
        print('End A')
class B:
    def __init__(self):
        print('Start B')
        print('End B')
class C:
    def __init__(self):
        print('Start C')
        print('End C')
class D:
    def __init__(self):
        print('Start D')
        print('End D')
class MyClass1(B,A,C):
    def __init__(self):
        print('Start MyClass1')
        super(MyClass1,self).__init__()
        print('End MyClass1')
class MyClass2(MyClass1,D):
    def __init__(self):
        print('Start MyClass2')
        super(MyClass2,self).__init__()
        print('End MyClass2')
MyClass2()
复制代码

这段代码的继承关系比较复杂,可以用图2来表示。

图2

 

运行这段代码,会输出如下内容:
Start MyClass2
Start MyClass1
Start B
End B
End MyClass1
End MyClass2

 

从输出结果也可以再次验证前面的推论,也就是super会调用父类列表中第一个父类的成员。如MyClass1是MyClass2的第1个父类,所以MyClass2类会调用MyClass1类的构造方法,而B类是MyClass1类的第一个父类,所以MyClass1类会调用B类的构造方法。

但这里有一个问题,如果在MyClass2类中想调用D类的构造方法,在MyClass1类中想调用A类的构造方法,该怎么办呢?当然,可以直接使用父类名进行调用,那么使用super应该如何调用。

其实Python编译器在解析类时,会将当前类的所有父类(包括直接和间接父类)按一定的规则进行排序,然后会根据super类构造方法的第一个参数的值决定使用哪一个父类。那么这个顺序是怎样的呢?

现在先不用管这个顺序,先将图2的继承关系图倒过来,变成图3的多叉树。

 

图3

 

现在按深度优先遍历这颗二叉树,得到的遍历结果如下:

MyClass2 > MyClass1 > B > A > X1 > X2 > C > D

 

假设在MyClass2中要调用B类的构造方法,那么可以使用下面的代码。

super(MyClass1, self).__init__()

 

假设在MyClass2中要调用X2类的构造方法,那么可以使用下面的代码。

super(X1, self).__init__()

 

从这个规律可以看出,选择父类的规则是super类构造方法的第1个参数值在前面深度优先遍历序列中对应类的下一个类。例如,super(X1,self)就会去寻找X1的下一个类,也就是X2。如果super类构造方法的第1个参数值正好是深度优先遍历序列的最后一个类,本例是D,那么super将不会选择MyClass2的任何父类,也就是super什么都不会做(相当于一条空语句)。到现在为止,我们好像已经清楚了前面提到的一些疑问的答案。例如,super类构造方法的第1个参数值其实是对继承树深度优先遍历列表搜索的key,而第2个参数值其实是用来得到这个列表的。但真相真的是这样吗?

4. MRO算法

好像通过多叉树的深度优先遍历就可以解决父类的顺序问题,但很多时候,类的继承关系并不是传统的树,例如下面这段代码的继承关系就是一个菱形。

super5.py

复制代码
class Base:
    def __init__(self):
        print('Start Base')
        print('End Base')
class A(Base):
    def __init__(self):
        print('Start A')
        super(A,self).__init__()
        print('End A')


class B(Base):
    def __init__(self):
        print('Start B')
        super(B, self).__init__()
        print('End B')
class C(A,B):
    def __init__(self):
        print('Start C')
        super(C, self).__init__()
        print('End C')
C()
复制代码

运行结果如下:

Start C

Start A

Start B

Start Base

End Base

End B

End A

End C

 

这段代码的继承关系如图4所示。

图4

你就算把图倒过来,样子仍然不会变,如图5所示。

图5

 

这压根不是一颗多叉树,有点像一个图。对于图6所示的继承关系,是无法用深度优先遍历得到父类的顺序的,所以为了弥补深度优先遍历的缺陷,有人提出了MRO算法,MRO是Method Resolution Order三个单词的缩写。

 

那么什么是MRO算法呢?

 

MRO算法:

MRO算法是一个典型的递归操作,现在假设有如下两个函数:

1. mro:用于得到指定类的父类MRO列表。接收一个type参数,表示指定的类,如mro(C)

2. merge:用于合并多个父类列表,合并的规则如下:

如果一个父类列表的第一个元素,在其他父类列表中也是第一个元素,或不在其他父类列表中出现,则从所有待合并父类列表中删除这个元素(不存在的不需要删除),合并到当前的mro父类列表中。  现在拿前面的菱形继承关系为例说明如何得到MRO序列。这个序列的第一个元素就是C。有如下公式:

mro(C) = [C] + merge(mro(A), mro(B) ,[A,B])

 

其中merge函数有3个参数,分别是mro(A)、mro(B)和[A,B],也就是要将A和B的序列和[A,B]合并。根据前面的规则,有如下推导过程

mro(C) = [C] + merge(mro(A), mro(B) ,[A,B])

= [C] + merge([A,Base],[B,Base] ,[A,B])

= [C,A] + merge([Base],[B,Base],[B])

= [C,A,B] + merge([Base],[Base])

= [C,A,B,Base]

 

所以最终C类对应的mro序列为[C,A,B,Base],读者可以运行前面的代码,会得到如下的结果:

Start C

Start A

Start B

Start Base

End Base

End B

End A

End C

 

这也就是为什么会依次调用A、B和Base类构造方法的原因,因为MRO序列就是按这个顺序排列的。如果想调用B类的构造方法,需要使用super(A,self).__init()__,系统会在MRO序列中搜索A,然后会调用A的下一个类(也就是B)的构造方法。对于更复杂的继承关系,使用MRO算法自己计算MRO序列非常麻烦,所以可以使用mro方法直接输出MRO序列,代码如下:

print(C.mro())

执行这行代码,会输出如下内容:

[<class ‘__main__.C’>, <class ‘__main__.A’>, <class ‘__main__.B’>, <class ‘__main__.Base’>, <class ‘object’>]

原文地址https://www.cnblogs.com/nokiaguy/p/11976624.html

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS