Python——继承与派生

一、继承介绍

什么是继承

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

  • 注意：python中支持多继承即一个子类可以继承多个父类

    class Parent1(object):
    x=1111

class Parent2(object):
    pass

class Sub1(Parent1): # 单继承
    pass

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

print(Sub1.__bases__)
print(Sub2.__bases__)

print(Sub1.x)


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

# ps2:在python3中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
print(Parent1.__bases__)
print(Parent2.__bases__)

# python的多继承
#     优点：子类可以同时遗传多个父类的属性，最大限度地重用代码
#     缺点：
#         1、违背人的思维习惯：继承表达的是一种什么"是"什么的关系
#         2、代码可读性会变差
#         3、不建议使用多继承，有可能会引发可恶的菱形问题，扩展性变差，
#         如果真的涉及到一个子类不可避免地要重用多个父类的属性，应该使用Mixins

二、继承与抽象

为何要用继承

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

如何实现继承

# 示范1：类与类之间存在冗余问题
class Student:
    school='OLDBOY'

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

    def choose_course(self):
        print('学生%s 正在选课' %self.name)


class Teacher:
    school='OLDBOY'

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

    def score(self):
        print('老师 %s 正在给学生打分' %self.name)
        
# 示范2：基于继承解决类与类之间的冗余问题
class OldboyPeople:
    school = 'OLDBOY'

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


class Student(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id = stu_id

    def choose_course(self):
        print('学生%s 正在选课' % self.name)
stu_obj = Student('lili', 18, 'female')
print(stu_obj.__dict__)
print(stu_obj.school)
stu_obj.choose_course()

class Teacher(OldboyPeople):
    #           老师的空对象，'egon',18,'male',3000,10
    def __init__(self, name, age, sex, salary, level):
        # 指名道姓地跟父类OldboyPeople去要__init__
        OldboyPeople.__init__(self,name,age, sex)
        self.salary = salary
        self.level = level


    def score(self):
        print('老师 %s 正在给学生打分' % self.name)

tea_obj=Teacher('egon',18,'male',3000,10)
print(tea_obj.__dict__)
print(tea_obj.school)

tea_obj.score()
  • 抽象

Python——继承与派生

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

    Python——继承与派生

  • 基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系

  • 上述代代码中Student类与Teacher类都存在着重复的代码，student与teacher都是人类，所以得出继承关系

    class OldboyPeople:
    school = 'OLDBOY'

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

class Student(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id = stu_id

    def choose_course(self):
        print('学生%s 正在选课' % self.name)
 
class Teacher(OldboyPeople):
    #           老师的空对象，'egon',18,'male',3000,10
    def __init__(self, name, age, sex, salary, level):
        # 指名道姓地跟父类OldboyPeople去要__init__
        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() # obj.f1()

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

obj=Bar()
obj.f2()

# Foo.f2
# Bar.f1
'''
obj.f2()会在父类Foo中找到f2，先打印Foo.f2,然后执行到self.f1(),即obj.f1()，
仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去，在类Bar中找到f1，因而打印结果为Bar.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('Bar.f1')
... 
>>> 
>>> obj=Bar()
>>> obj.f2() #在父类中找到f2方法，进而调用obj._Foo__f1()方法，同样是在父类中找到该方法
Foo.f2
Foo.f1

四、继承的实现原理

4.1 菱形问题

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

    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的继承实现原理

4.2 继承原理

  • 针对python到底是如何实现继承的，每当我们定义一个类，python就会计算出一个方法解析顺序列表即MRO列表我们可以使用mro()这个内置方法查看MRO列表的内容

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

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

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

4.3 深度优先和广度优先

  • 非菱形结构

    Python——继承与派生

    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——继承与派生

    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——继承与派生

    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来进行验证

4.4 python Mixins机制

  • 用来解决多继承所带来的问题的，将原本的混乱的继承清晰的变成’is-a‘的关系

    # 民航飞机、直升飞机、汽车都是交通工具，但是飞机会飞，汽车不会，
# 这个时候我们将飞这个功能放到交通工具中就显得不合适
class Vehicle:  # 交通工具
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


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


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


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

# 针对上面的问题，就引入Mixin机制
# Mixin机制指的就是子类混合不同类的功能，然后将其用统一的命名规范来标识该类只是用来混合功能的
# 从而来遵守多继承下的“is-a”关系，Mixin机制本质仍是多继承
class Vehicle:  # 交通工具
	pass

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


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


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


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

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

五、派生与方法重用

5.1 什么是派生

  • 子类中衍生出的新东西

    • 1、子类独有，父类没有
    • 2、子类有、父类也有，子类是完全覆盖父类的
    • 3、子类有、父类也有，子类是在父类的基础上进行拓展
    >>> class People:
...     school='清华大学'
...     
...     def __init__(self,name,sex,age):
...         self.name=name
...         self.sex=sex
...         self.age=age
... 
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title): # 派生
...         self.name=name
...         self.sex=sex
...         self.age=age
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)

  • 想在子类派生出的方法内重用父类的功能，有两种实现方式

    # 方法一：“指名道姓”地调用某一个类的函数=》不依赖于继承
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title):
...         People.__init__(self,name,age,sex) #调用的是函数,因而需要传入self
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)

# 方法二：super()调用父类提供给自己的方法=》严格依赖继承关系
# 调用super()会得到一个特殊的对象，该对象会按照发起属性查找的类的mro去当前类的父类中找属性
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title):
...         super().__init__(name,age,sex) #调用的是绑定方法，自动传入self
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)


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

六、组合

什么是组合

  • 在一个类中以另外一个类的对象作为数据属性，称为类的组合。
# 组合与继承都是用来解决代码的重用性问题。
# 二者的区别在于
'''
继承：强调‘是’的关系，例如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承
组合：强调‘有’的关系，例如老师有多门课程，老师有给学生打分，当类之间有显著不同，并且较小的类是较大的类所需
要的组件时，应该使用组合
'''
class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell_birth(self):
       print('<%s-%s-%s>' %(self.year,self.mon,self.day))

class People:
    school='清华大学'
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码
class Teacher(People): #老师是人
    def __init__(self,name,sex,age,title,year,mon,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,mon,day) #老师有生日
        self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象
    def teach(self):
        print('%s is teaching' %self.name)


python=Course('python','3mons',3000.0)
linux=Course('linux','5mons',5000.0)
teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)

# teacher1有两门课程
teacher1.courses.append(python)
teacher1.courses.append(linux)

# 重用Date类的功能
teacher1.birth.tell_birth()

# 重用Course类的功能
for obj in teacher1.courses: 
    obj.tell_info()

相关文章：

  • 2022-12-23
  • 2022-12-23
  • 2022-12-23
  • 2022-01-19
猜你喜欢
  • 2021-05-16
  • 2022-12-23
  • 2019-11-26
  • 2021-09-02
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode