面向对象之继承

继承的介绍

继承是一种创建新类的方式,新建的类可以称为子类或派生类, 父类又可称为基类或超类, 子类会遗传父类的属性和方法
需要注意的是: 在Python中, 新建的类可以继承一个或多个父类, 在Python中, 新建的类可以继承一个或多个父类。

使用继承主要是为了解决代码冗余问题。

案例一: 类与类之间存在冗余问题

class Student(object):
    school = 'hnie'

    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(object):
    school = 'hnie'

    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)

案例二:  基于继承解决类与类之间的冗余问题

class HniePeople(object):
    school = 'hnie'

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


class Student(HniePeople):

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


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

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


stu1 = Student('featherwit', 18, 'female')
print(stu1.__dict__)
print(stu1.school)
stu1.choose_cource()

tea1 = Teacher('featherwit', 18, 'female', 3000, 10)
print(tea1.__dict__)
print(tea1.school)
tea1.score()

在Python2中有经典类和新式类之分:

• 新式类: 继承了object类的子类, 以及该子类的子类和子孙类
• 经典类: 没有继承object类的子类, 以及该子类的子类和子孙类

在Python3中没有继承任何类, 那么会默认继承object类, 所以Python3中所有的类都是新式类

多继承存在的问题

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

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

注意: 如果两个父类都继承自object类, 那么这不算是菱形问题

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


class B(object):
    def test(self):
        print('from B')


class C(B, A):
    def test(self):
        print('from C')

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

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

继承原理

Python到底是如何实现继承的呢? 对于你定义的每个类, Python都会计算出一个方法解析顺序(MRO)列表, 该MRO列表就是一个简单的所有基类的线性顺序列表
python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查

2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
所以obj.test()的查找顺序是, 先从对象obj本身的属性里找方法test, 没有找到, 则参照属性查找发起者(即obj)所处类D的MRO列表来依次检索, 首先在类D中未找到, 然后再B中找到方法test

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

总结: 类相关的属性查找(类名.属性, 该类的对象.属性), 都是参照该类的mro

类的继承特点: 深度优先与广度优先

多继承为非菱形结构

如果多继承是非菱形继承, Python2与Python3的属性查找顺序是一样的, 都是一个分支一个分支地找下去, 然后最后找object, 这就是深度优先

class E(object):
    def test(self):
        print('from E')


class F(object):
    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(object):
    def test(self):
        print('from D')


class A(B, C, D):
    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()
print(obj.test())

多继承为菱形结构

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

当类是经典类时, 多继承情况下, 在要查找的属性不存在时, 会按照深度优先的方式查找下去

当类是新式类时, 多继承情况下, 在要查找的属性不存在时, 会按照广度优先的方式查找下去

多继承的Mixins机制

Mixins机制核心: 就是在多继承背景下, 尽可能的提升多继承的可读性。也就是说让多继承满足人的思维逻辑("is-a")的问题

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

class Vehicle(object):
    pass


class FlyableMixin(object):
    def fly(self):
        pass


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


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


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

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

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

方法的重写

子类可以派生出自己新的属性，在进行属性查找时，子类中的属性名会优先于父类被查找，例如每个老师还有职称这一属性，我们就需要在Teacher类中定义该类自己的__init__覆盖父类的

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)

很明显子类Teacher中__init__内的前三行又是在写重复代码，若想在子类派生出的方法内重用父类的功能，有两种实现方式

方式一:  精确的调用某一个类下的函数 -> 不依赖与继承关系

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

    def f1(self):
        print('%s say hello!' % self.name)


class Teacher(People):
    def __init__(self, name, age, sex, level, salary):
        People.__init__(self, name, age, sex)

        self.level = level
        self.salary = salary


tea_obj = Teacher('featherwit', 18, 'man', '1', 10000)

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

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

    def f1(self):
        print('%s say hello!' % self.name)


class Teacher(People):
    def __init__(self, name, age, sex, level, salary):
        # super(Teacher, self).__init__(name, age, self)
        super().__init__(name, age, sex)  # 调用的是方法, 自动传入参数

        self.level = level
        self.salary = salary


print(Teacher.mro())
tea_obj = Teacher('featherwit', 18, 'man', '1', 10000)
print(tea_obj.__dict__)

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

super()使用的小案例

class A:
    def test(self):
        super().test()


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


class C(A, B):
    pass


obj = C()
obj.test()  # from B
print(C.mro())

obj.test()首先找到A下的test方法，执行super().test()会基于MRO列表(以C.mro()为准)当前所处的位置继续往后查找()，然后在B中找到了test方法并执行。