码迷，mamicode.com
首页 > 其他好文 > 详细

29 继承和派生

时间：2021-04-01 13:23:05      阅读：0      评论：0      收藏：0      [点我收藏+]

标签：飞机   教师   命名规范   raft   匹配   理解   html   label   回到顶部   

 

 

回到顶部

一 继承介绍

　　1.1 什么是继承

　　　　继承是一种创建新类的方式，新建的类可称为子类或派生类，父类又可称为基类或超类,子类会遗传父类的属性

　　　　需要注意的是：python支持多继承,新建的类可以继承一个或多个父类

 
class Parent1(object):
    x=1111

class Parent2(object):
    pass

class Sub1(Parent1): # 单继承
    pass

class Sub2(Parent1,Parent2): # 多继承
    pass

print(Sub1.__bases__)#__bases__可以查看类继承的所有父类
print(Sub2.__bases__)
 

　　　　python的多继承优缺点：

　　　　优点：子类可以同时遗传多个父类的属性，最大限度地重用代码

　　　　缺点：1、违背人的思维习惯：继承表达的是一种什么"是"什么的关系

　　　　　　   2、代码可读性会变差

　　　　　　   3、不建议使用多继承，有可能会引发可恶的菱形问题，扩展性变差。如果真的涉及到一个子类不可避免地要重用多个父类的属性，应该使用Mixins　

技术图片 
#在python2中有经典类与新式类之分
# 新式类：继承了object类的子类，以及该子类的子类子子类。。。
# 经典：没有继承object类的子类，以及该子类的子类子子类。。。

#在python3中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
注

 

　　1.2 为什么要有继承

　　　　用来解决类与类之间代码冗余问题

回到顶部

二 继承与抽象（如何使用继承）

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

　　基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）。子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。

 
class OldboyPeople: #定义一个父类
    school = ‘OLDBOY‘
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class Student(OldboyPeople):#学生类继承父类
    def choose(self):
        print(‘学生%s 正在选课‘%self.name)

class Teacher(OldboyPeople):#教师类继承父类
     # 指名道姓地跟父类OldboyPeople去要__init__ 
    def __init__(self,name,age,sex,salary,level):
        OldboyPeople.__init__(self,name,age,sex)
        self.salary = salary
        self.level = level
    def score(self):
        print(‘老师 %s 正在给学生打分‘%self.name)
 

 

回到顶部

四 属性查找

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

 
class Foo:
    def f1(self):
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        self.f1()

class Bar(Foo):
     def f1(self):
         print(‘Bar.f1‘)

b = Bar()
b.f2()
Foo.f2
Bar.f1
 

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

 
class Foo:
    def __f1(self):# 变形为_Foo__f1
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        self.__f1()# 变形为self._Foo__f1,因而只会调用自己所在的类中的方法

class Bar(Foo):
     def __f1(self):# 变形为_Bar__f1
         print(‘Bar.f1‘)
b = Bar()
b.f2()
Foo.f2
Foo.f1
 
回到顶部

五 继承的实现原理

　　5.1 菱形问题

　　　　因为python中支持多继承，一个子类是可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但是这也带来了菱形问题(或称钻石问题，有时候也被称为“死亡钻石”)

                                                                                                                技术图片

　　　　这种继承结构下导致的问题称之为菱形问题：如果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的继承实现原理
 

　　5.2 继承原理

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

 
print(D.mro()) # 类D以及类D的对象访问属性都是参照该类的mro列表
[<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]

#python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止
‘’’
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
‘’‘

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

 

　　5.3 深度优先和广度优先

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

　　　　　　　　　　　　　　　　　　　　　　　　技术图片

 

 
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，分别对应属性的两种查找方式：深度优先和广度优先

　　　　经典类：深度优先，会在检索第一条分支的时候就直接一条道走到黑，即会检索大脑袋（共同的父类）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　技术图片

 
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中进行测试
 

　　　　新式类：广度优先，会在检索最后一条分支的时候检索大脑袋

　　　　　　　　　　　　　　　　　　　　　　　　　　　　技术图片

 
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来进行验证
 
回到顶部

 六 python Mixins机制

　　多继承的正确打开方式：mixins机制

　　mixins机制核心：就是在多继承背景下尽可能地提升多继承的可读性

　　ps：让多继承满足人的思维习惯=》什么"是"什么

　　民航飞机、直升飞机、轿车都是一个（is-a）交通工具，前两者都有一个功能是飞行fly，但是轿车没有，所以把飞行功能放到交通工具这个父类中是不合理的

　　怎么办？？？为了尽可能地重用代码，那就只好在定义出一个飞行器的类，然后让民航飞机和直升飞机同时继承交通工具以及飞行器两个父类，这样就出现了多重继承。

　　Python提供了Mixins机制，简单来说Mixins机制指的是子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀），以此标识这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的，所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系，如下

 

 
class Vehicle:  # 交通工具
    pass


class FlyableMixin:
    def fly(self):
        ‘‘‘
        飞行功能相应的代码        
        ‘‘‘
        print("I am flying")


class CivilAircraft(FlyableMixin, Vehicle):  # 民航飞机
    pass


class Helicopter(FlyableMixin, Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车
    pass

# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路
‘’‘
可以看到，上面的CivilAircraft、Helicopter类实现了多继承，不过它继承的第一个类我们起名为FlyableMixin，
而不是Flyable，这个并不影响功能，但是会告诉后来读代码的人，这个类是一个Mixin类，表示混入(mix-in)，
这种命名方式就是用来明确地告诉别人（python语言惯用的手法），这个类是作为功能添加到子类中，而不是作为父类，
它的作用同Java中的接口。所以从含义上理解，CivilAircraft、Helicopter父类都只是一个Vehicle，而不是一个飞行器。
‘’‘
 

　　使用Mixin类实现多重继承要非常小心

  • 首先它必须表示某一种功能，而不是某个物品，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
  • 其次它必须责任单一，如果有多个功能，那就写多个Mixin类，一个类可以继承多个Mixin，为了保证遵循继承的“is-a”原则，只能继承一个标识其归属含义的父类
  • 然后，它不依赖于子类的实现
  • 最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了）

 

回到顶部

七 派生和方法重用

　　7.1 派生

　　　　派生是子类中衍生出的新东西

　　　　1、子类独有，父类没有

　　　　2、子类有，父类也有，子类是完全覆盖父类的

　　　　3、子类有，父类也有，子类是在父类的基础上进行拓展

　　7.2 方法重用

　　　　方式一：指名道姓调用某一个类下的函数=》不依赖于继承关系

 
class OldboyPeople: #定义一个父类
    school = ‘OLDBOY‘
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

class Teacher(OldboyPeople):  # 教师类继承父类
    # 指名道姓地跟父类OldboyPeople去要__init__ 
    def __init__(self, name, age, sex, salary, level):
        OldboyPeople.__init__(self, name, age, sex)
        self.salary = salary
        self.level = level
    def score(self):
        print(‘老师 %s 正在给学生打分‘ % self.name)
 

　　　　方式二：super()调用父类提供给自己的方法=》严格依赖继承关系

　　　　调用super()会得到一个特殊的对象，该对象会参照发起属性查找的那个类的mro,去当前类的父类中找属性

 
class Teacher(People):
     def __init__(self,name,sex,age):
         # python3中可以简写为super()。
         super().__init__(name,age,sex) #调用的是绑定方法，自动传入self
         # 在Python2中super的使用需要完整地写成super(自己的类名, self)
         super(Teacher,self).__init__(name,age,sex)
         self.salary = salary
         self.level = level
     def score(self):
         print(‘老师 %s 正在给学生打分‘ % self.name)
 

　　　　案例

 
class A:
    def test(self):
        print(‘from A‘)
        super().test()

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

class C(A,B):
    pass
print(C.mro())
# [<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
# 在代码层面A并不是B的子类，但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”
obj=C()
obj.test() # 属性查找的发起者是类C的对象obj，所以中途发生的属性查找都是参照C.mro()

29 继承和派生

标签：飞机   教师   命名规范   raft   匹配   理解   html   label   回到顶部   

原文地址：https://www.cnblogs.com/OUYANGjt/p/14603925.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！