python学习28——继承与派生

一 继承介绍

继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,新建的类可称为子类或派生类,父类又可称为基类或超类

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承
    pass

class SubClass2(ParentClass1,ParentClass2): #多继承
    pass

通过类的内置属性__bases__可以查看类继承的所有父类

>>> SubClass2.__bases__
(<class ‘__main__.ParentClass1‘>, <class ‘__main__.ParentClass2‘>)

在Python2中有经典类与新式类之分,没有显式地继承object类的类,以及该类的子类,都是经典类,显式地继承object的类,以及该类的子类,都是新式类。而在Python3中,即使没有显式地继承object,也会默认继承该类,如下

>>> ParentClass1.__bases__
(<class ‘object‘>,)
>>> ParentClass2.__bases__
(<class ‘object‘>,)

因而在Python3中统一都是新式类,关于经典类与新式类的区别,我们稍后讨论

提示:object类提供了一些常用内置方法的实现,如用来在打印对象时返回字符串的内置方法__str__

二 继承与抽象

要找出类与类之间的继承关系,需要先抽象,再继承。抽象即总结相似之处,总结对象之间的相似之处得到类,总结类与类之间的相似之处就可以得到父类,如下图所示

python学习28——继承与派生

基于抽象的结果,我们就找到了继承关系

python学习28——继承与派生

基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系(比如人类,猪类,猴类都是动物类)。子类可以继承/遗传父类所有的属性,因而继承可以用来解决类与类之间的代码重用性问题。比如我们按照定义Student类的方式再定义一个Teacher类

class Teacher:
    school=‘清华大学‘

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

    def teach(self):
        print(‘%s is teaching‘ %self.name)

类Teacher与Student之间存在重复的代码,老师与学生都是人类,所以我们可以得出如下继承关系,实现代码重用

class People:
    school=‘清华大学‘

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

class Student(People):
    def choose(self):
        print(‘%s is choosing a course‘ %self.name)

class Teacher(People):
    def teach(self):
        print(‘%s is teaching‘ %self.name)

Teacher类内并没有定义__init__方法,但是会从父类中找到__init__,因而仍然可以正常实例化,如下

>>> teacher1=Teacher(‘lili‘,‘male‘,18)
>>> teacher1.school,teacher1.name,teacher1.sex,teacher1.age
(‘清华大学‘, ‘lili‘, ‘male‘, 18)

三 属性查找

有了继承关系,对象在查找属性时,先从对象自己的__dict__中找,如果没有则去子类中找,然后再去父类中找……

>>> class Foo:
...     def f1(self):
...         print(‘Foo.f1‘)
...     def f2(self):
...         print(‘Foo.f2‘)
...         self.f1()
... 
>>> class Bar(Foo):
...     def f1(self):
...         print(‘Foo.f1‘)
... 
>>> b=Bar()
>>> b.f2()
Foo.f2
Foo.f1

b.f2()会在父类Foo中找到f2,先打印Foo.f2,然后执行到self.f1(),即b.f1(),仍会按照:对象本身->类Bar->父类Foo的顺序依次找下去,在类Bar中找到f1,因而打印结果为Foo.f1

父类如果不想让子类覆盖自己的方法,可以采用双下划线开头的方式将方法设置为私有的

>>> class Foo:
...     def __f1(self): # 变形为_Foo__fa
...         print(‘Foo.f1‘) 
...     def f2(self):
...         print(‘Foo.f2‘)
...         self.__f1() # 变形为self._Foo__fa,因而只会调用自己所在的类中的方法
... 
>>> class Bar(Foo):
...     def __f1(self): # 变形为_Bar__f1
...         print(‘Foo.f1‘)
... 
>>> 
>>> b=Bar()
>>> b.f2() #在父类中找到f2方法,进而调用b._Foo__f1()方法,同样是在父类中找到该方法
Foo.f2
Foo.f1

四 继承的实现原理

4.1 菱形问题

? 大多数面向对象语言都不支持多继承,而在Python中,一个子类是可以同时继承多个父类的,这固然可以带来一个子类可以对多个不同父类加以重用的好处,但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题,有时候也被称为“死亡钻石”),菱形其实就是对下面这种继承结构的形象比喻

python学习28——继承与派生

A类在顶部,B类和C类分别位于其下方,D类在底部将两者连接在一起形成菱形。

这种继承结构下导致的问题称之为菱形问题:如果A中有一个方法,B和/或C都重写了该方法,而D没有重写它,那么D继承的是哪个版本的方法:B的还是C的?如下所示

class A(object):
    def test(self):
        print(‘from A‘)


class B(A):
    def test(self):
        print(‘from B‘)


class C(A):
    def test(self):
        print(‘from C‘)


class D(B,C):
    pass


obj = D()
obj.test() # 结果为:from B

要想搞明白obj.test()是如何找到方法test的,需要了解python的继承实现原理

4.2 继承原理

python到底是如何实现继承的呢? 对于你定义的每一个类,Python都会计算出一个方法解析顺序(MRO)列表,该MRO列表就是一个简单的所有基类的线性顺序列表,如下

>>> D.mro() # 新式类内置了mro方法可以查看线性列表的内容,经典类没有该内置该方法
[<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]

python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

所以obj.test()的查找顺序是,先从对象obj本身的属性里找方法test,没有找到,则参照属性查找的发起者(即obj)所处类D的MRO列表来依次检索,首先在类D中未找到,然后再B中找到方法test

ps:

1.由对象发起的属性查找,会从对象自身的属性里检索,没有则会按照对象的类.mro()规定的顺序依次找下去,
2.由类发起的属性查找,会按照当前类.mro()规定的顺序依次找下去,

4.3 深度优先和广度优先

参照下述代码,多继承结构为非菱形结构,此时,会按照先找B这一条分支,然后再找C这一条分支,最后找D这一条分支的顺序直到找到我们想要的属性

python学习28——继承与派生

class E:
    def test(self):
        print(‘from E‘)


class F:
    def test(self):
        print(‘from F‘)


class B(E):
    def test(self):
        print(‘from B‘)


class C(F):
    def test(self):
        print(‘from C‘)


class D:
    def test(self):
        print(‘from D‘)


class A(B, C, D):
    # def test(self):
    #     print(‘from A‘)
    pass


print(A.mro())
‘‘‘
[<class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘__main__.E‘>, <class ‘__main__.C‘>, <class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘object‘>]
‘‘‘

obj = A()
obj.test() # 结果为:from B
# 可依次注释上述类中的方法test来进行验证

如果继承关系为菱形结构,那么经典类与新式类会有不同MRO,分别对应属性的两种查找方式:深度优先和广度优先

python学习28——继承与派生

class G: # 在python2中,未继承object的类及其子类,都是经典类
    def test(self):
        print(‘from G‘)

class E(G):
    def test(self):
        print(‘from E‘)

class F(G):
    def test(self):
        print(‘from F‘)

class B(E):
    def test(self):
        print(‘from B‘)

class C(F):
    def test(self):
        print(‘from C‘)

class D(G):
    def test(self):
        print(‘from D‘)

class A(B,C,D):
    # def test(self):
    #     print(‘from A‘)
    pass

obj = A()
obj.test() # 如上图,查找顺序为:obj->A->B->E->G->C->F->D->object
# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试

python学习28——继承与派生

class G(object):
    def test(self):
        print(‘from G‘)

class E(G):
    def test(self):
        print(‘from E‘)

class F(G):
    def test(self):
        print(‘from F‘)

class B(E):
    def test(self):
        print(‘from B‘)

class C(F):
    def test(self):
        print(‘from C‘)

class D(G):
    def test(self):
        print(‘from D‘)

class A(B,C,D):
    # def test(self):
    #     print(‘from A‘)
    pass

obj = A()
obj.test() # 如上图,查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

相关推荐