第三十篇 面向对象的三大特性之继承 supre()

继承

• 一 、什么是继承？

类的继承跟现实生活中的父、子、孙子、重孙子的继承关系一样，父类又称基类。

Python中类的继承分为：单继承 和  多继承。

# 定义父类
class ParentClass1:  # 父
    pass

class ParentClass2:   # 母
    pass

# 继承的方式
class subClass(ParentClass1):  # 单继承  蚯蚓是雌雄同体
    pass

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

继承的方式

• 二 、子类到底继承了父类的什么属性？

子类调用属性的顺序：先从子类自己的属性字典里找，没有的时候，再去从父类的属性字典里去找。

子类继承了父类的所有属性

有人说，子类继承了父类的所有属性，子类自定义的属性如果跟父类重名了，那就覆盖了父类的-----错误的哦。看示例

class Dad:
    '这个是爸爸类'
    money=10

    # 初始化父类
    def __init__(self,name):
        print('爸爸')
        self.name=name

    def hit_son(self):
        print('%s 正在教育儿子' %self.name)

class Son(Dad):
    money = 1000000000009
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def hit_son(self):
        print('来自儿子类')

s1=Son('alex',18)
s1.hit_son()   # 来自儿子类
print(s1.money)   #
print(Dad.money)  #

'''
很显然，子类调用自己的money属性结果是1000000000009，
而父类调用也调用自己的money属性结果是10
如果按照上面说的，子类和父类属性重名，就是覆盖了父类，那应该Dad.money的结果也应该是1000000000009，但实际结果并不是。

所以，当子类的属性与父类的属性重名了，就是子类覆盖了父类的属性，这是错误的。
'''

子类与父类属性重名，就是子类属性覆盖了父类的，证明这是错误的

• 三、什么时候用继承？

1、当类之间有显著的不同，并且较小的类是较大的类所需要的组件时，用组合比较好（一个大类由很多个小类拼接而成的，用组合）

例如：描述一个机器人类，机器人这个大类是由很多互不相关的小类组成，如机械胳膊类，腿类，脚类、身体类、电池类等

2、当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好

例如

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能，如下示例

class cat:
    def miaomiaojiao(self):
        print("miaomiaojiao")

    def chi(self):
        pass
    def he(self):
        pass
    def la(self):
        pass
    def sa(self):
        pass

class dog:
    def wangwangjiao(self):
        print("wangwangjiao")

    def chi(self):
        pass

    def he(self):
        pass

    def la(self):
        pass

    def sa(self):
        pass

如果没有继承，只能这么写，重复的写相同的功能

# 通过观察可以知道，cat类和dog类，都有重复的 chi he la sa 属性，那这个属于有很多相同的功能，可以提取出来
# 组成一个动物类
class Animal:

    def eat(self):
        print("%s 吃 " % self.name)

    def drink(self):
        print("%s 喝 " % self.name)

    def shit(self):
        print("%s 拉 " % self.name)

    def pee(self):
        print("%s 撒 " % self.name)

#　然后猫可以继承动物类，狗也可以继承动物类
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class Cat(Animal):
    # Animal类没有初始化方法，而猫可以定义自己的初始化方法，这就是派生
    def __init__(self, name):
        self.name = name
        self.breed = '猫'
    # 然后猫也有自己的喵喵叫的属性，这个叫派生
    def cry(self):
        print('喵喵叫')

class Dog(Animal):
    # Animal类没有初始化方法，而狗可以定义自己的初始化方法，这就是派生
    def __init__(self, name):
        self.name = name
        self.breed = '狗'

    # 狗也有自己的汪汪叫的属性，这个也叫派生
    def cry(self):
        print('汪汪叫')

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

通过继承，就可以把相同的功能提取出来减少重复代码

继承过来的吃喝拉撒，属于继承的基类；猫喵喵叫方法和狗的汪汪叫方法，则是派生（衍生），就是子类又派生出自己的方法或者属性。

• 四、继承同时具有两种含义

含义1：继承基类的方法，并且做出自己的改变或者扩展（优点：可代码重用）

含义2：声明某个子类兼容与某个基类，定义一个接口类，子类继承接口类，并且实现接口中定义的方法（接口继承）

实践中，继承的第一种含义并不是很大，甚至常常是有害的。因为它使得子类和基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。

接口继承实质上是要求“做出一个良好的抽象， 这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可以一视同仁的处理实现了特定接口的

所有对象”——这在程序设计上，叫做归一化。

接口：接口就是一个方法， 就是一个函数。

白话文接口继承：就是说父类规定好了，子类必须实现什么方法，但是父类里不具体实现。而子类只要一继承了父类，子类就必须自己去具体的实现父类规定的要实现的方法。

class All_file():
   # 父类规定了必须要实现的read和write方法
    def read(self):
        pass

    def write(self):
        pass

class Disk(All_file):
   # 子类只要继承了父类，就需要具体的去实现read和write方法
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')

class Mem(All_file):
    def read(self):
        print('mem read')
     # 但是，子类说了，我就不实现write方法，你能怎么着？

# 实例化
m1=Mem()
m1.read()
m1.write()  # 子类没有自己的write方法，就可以调用父类的，但是父类没有具体实现，所有什么也没有。

所以，这不是真正的接口继承，真正的接口继承，子类必须实现write方法才可以那。

接口继承的原理伪代码，不是正在的接口继承

真正的接口继承

为什么说上面不是真正的接口继承，因为父类 All_file没有对接口起到限制作用。所以，学一下真正的接口继承吧。

Python没有直接的方法去实现真正的接口继承，需要借助一个模块abc来实现。

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod   # 装饰器　　　stract抽象，stractmethod:抽象的方法，就是说不需要具体实现的方法
    def read(self):
        pass

    @abc.abstractmethod   #　装饰器
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')

class Mem(All_file):
    def read(self):
        print('mem read')

    #  Mem 子类，不老实，虽然继承了All_file,但是却不老实，没有按照规定定义并实现write方法
    #  所以，当他在实例化的时候，就会报错

# 实例化
m1=Mem()
# TypeError: Can't instantiate abstract class Mem with abstract methods write
# 因为没有按照接口继承的规定实现write方法

真正的接口继承-子类不老实，没按规定实现父类规定的方法

真正的接口继承---子类老实了，子类老老实实的实现父类的规定。

import abc
class All_file(metaclass=abc.ABCMeta): # metaclass=abc.ABCMeta：必须要加的
    @abc.abstractmethod   # 装饰器　　　stract抽象，stractmethod:抽象的方法，就是说不需要具体实现的方法
    def read(self):
        pass

    @abc.abstractmethod   #　装饰器  必须要加的  接口类的方法是不需要实现的，接口类的方法主要目的是为了规范你的类。
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')

class Mem(All_file):
    def read(self):
        print('mem read')

   # 这下老实了，实现了write方法
    def write(self):
        print('mem write')

# 实例化
m1=Mem()
m1.read()
m1.write()

 接口继承有什么好处呢?

接口提取了一群类共同的函数，可以把接口当做一个函数的集合。

然后让子类去实现接口中的函数。

这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。

归一化的好处在于：

1. 归一化让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

2. 归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合

　　2.1：就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

　　2.2：再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样

• 五.继承顺序之MRO线性顺序列表

1、 要理解继承熟悉，得先知道经典类和新式类。

在Python2.7里，是区分经典类和形式类的

# 经典类
# 经典类的基类A是不继承于其他类的
class A:
    def test(self):
        pass

class B(A):
    pass

# 新式类
# 新式类的基类A是继承与object类
class A(object):
    def test1():
        pass

class B(A):
    def function():
        pass

在Python3里不区分经典类和新式类，统一都是新式类

# python3里下面两种方式都是新式类
# 即使A后面没有写（object），它也是继承与object的
class A:
    def test(self):
        pass

class B(A):
    pass

class A(object):
    def test1():
        pass

class B(A):
    def function():
        pass

深度优先的查找顺序：深度优先是第一条线就会找到基类

广度优先的查找顺序：广度优先最后一条线才找基类。

继承顺序示例代码：

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

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

class F(D,E):
    # def test(self):
    #     print('from F')
    pass

f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
# (<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
# 新式类的最后看到A是继承与类object的

#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

2、 继承的原理（python如何实现的继承）

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

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

• 六.子类中调用父类的方法

方法一：指名道姓，即父类名.父类方法() 的方式调用

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('我是来自父类的，要开动啦...')

class Subway(Vehicle): #地铁子类继承Vehicle基类
    # 初始化子类
    def __init__(self,name,speed,load,power,line):
        # 因为前四个熟悉都与父类一样，所以可以直接通过： 父类名.父类方法()的方式进行调用
        # 同时，父类的参数也要原样照搬
        Vehicle.__init__(self,name,speed,load,power)
        # 然后，再单独写子类自己特有的属性line
        self.line=line

    # 在子类里定义了自己的run方法，但同时，还需要用到父类的run方法里的功能
    def run(self):
        print('地铁%s号线欢迎您' %self.line)

        # 需要用到父类里run方法，可以直接通过：父类名.父类方法()的方式进行调用
        Vehicle.run(self)

line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

父类名.父类方法名()

方法二：super()的方式调用

通过 父类名.父类方法名()的方式调用，有个缺点，就是如果有很多子类里都这么调用了，当有一天父类名被改了，那所有的调用里都需要进行改，工作量很大，而且还有可能漏改。所以，有个super()调用方式则可以很好的解决这个问题

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power

     def run(self):
         print('我是来自父类的，要开动啦...')

class Subway(Vehicle): #地铁子类继承Vehicle基类
    # 初始化子类
    def __init__(self,name,speed,load,power,line):
        # super().父类方法名(没有self, 父类的需要被重用的参数)    注意：super().父类方法名(), 连self都不需要传了
        super().__init__(name,speed,load,power)   # 相当于super(Subway,self).__init__(name,speed,load,power)
        # 所以还可以写这个下面这种方式：
        # 两种方式完全是一样的，但是只能写一个哦
        # super(Subway,self).__init__(name,speed,load,power)
        # 然后，再单独写子类自己特有的属性line
        self.line=line

    # 在子类里定义了自己的run方法，但同时，还需要用到父类的run方法里的功能
    def run(self):
        print('地铁%s号线欢迎您' %self.line)

        # 需要用到父类里run方法，可以直接通过：super().父类方法()的方式进行调用, 注意与方法一的区别，不需要传self了
        # 写法一
        # super().run()
        # 写法二
        super(Subway,self).run()

# 实例化
line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

# 结果
地铁13号线欢迎您
我是来自父类的，要开动啦...

# 好处：
1. 调用的时候，不用再写父类名了
2. 调用的时候，不用再写self参数了
3. 当父类名变了的时候，只需要改一下子()括号里的父类名就好了，子类里面调用父类的逻辑不用变

super().父类方法名()

强调：二者使用哪一种都可以，但最好不要混合使用

再开一个例子(重要)

# 定义一个Fish鱼类，作为父类
class Fish(object):
    # 父类的构造方法里有什么参数，子类的构造方法里也需要有什么参数，父类再接，得子类先传
    def __init__(self, name,age):
        self.name = name
        self.age = age
    # 鱼类都有吐泡泡的能力
    def bubble(self):
        print("{0}吐一串泡泡！".format(self.name))
    # 鱼类都有游泳的能力
    def swam(self):
        print("{0}游得很快！".format(self.name))

# 定义一个多宝鱼，继承父类
class Turbot(Fish):
    # 每一种鱼在继承Fish的时候，进行初始化，如果父类有很多个参数，子鱼的初始化方法里就都需要写：
    # self.name = name
    # self.age = age
    # ...其他参数
    # 总之需要每个参数都写一遍
    # 为了解决这个问题，引入super方法，只需要一行就够了
    def __init__(self, name,age):
        # super(子类名，self:表示子类自己).父类的初始化方法 --- >这是super的写法
        # supre(参数1，参数2).方法名。
        # (1)super有两个参数：第一个是类型，要写子类名，第二个是对象名，要写self，其实就是具体的实例自己，用self表示
        # (2)通过. 调父类的方法
        super(Turbot, self).__init__(name,age)
   # 多宝鱼有跑的功能，可以通过super方法继承父类的swam方法，使多宝鱼自己也具有游泳的能力
    def run(self):
        super(Turbot,self).swam()

    # 类中有self和cls两个参数，self表示实例本身，cls表示类本身
    # 如果方法名里写了cls，表示balabala是一个类方法，既然是一个类方法，就需要有一个类方法 classmethod去修饰
    # 用classmethod类方法修饰的时候，有2个特性：
    # （1）可以直接用子类名.类方法名()进行调用
    # 举例：Turbot.balabala(),见下面的调用
    # 注意：这个被修饰的类方法在哪个类下面，就只能通过该类名去调用这个被修饰过的类方法，而不能通过其他类名去调用。
    # （2）也可以又这个子类产生的具体的实例去调用,因为实例也是从这个子类里产生的。
    # 举例：fish.balabala()
    @classmethod
    def balabala(cls):
        print("balabala")

    # 用静态方法staticmethod修饰，就表示这个方法就是一个普通的函数，也就是没有任何限制的。与写在类外面的函数是等价的。
    # 仅仅是写在了类里面而已的一个普通函数。因为它完全不需要self或cls去修饰。
    # 也就是kalakala这个函数就是一个普通的函数，既不属于Turbot这个类，也不属于具体的实例self.
    # 既然是一个普通的函数，也可以被该普通函数所在的类或者该子类产生的实例去调用
    @staticmethod
    def kalakala():
        print("kalakala")

# 定义一个鲸鱼，也继承父类
class Whale(Fish):

    def __init__(self, name):
        super(Whale, self).__init__(name)

Turbot.balabala()   # 子类名.类方法名()调用被classmethod修饰过的方法
Turbot.kalakala()   # 子类名.被staticmethod修饰过的普通方法
fish = Turbot('多宝鱼',3)  # 实例化一个多宝鱼
fish.balabala()   # 实例.被classmethod修饰过的类方法
fish.kalakala()   # 实例.被staticmethod修饰过的普通方法

了解部分：

即使没有直接继承关系，super仍然会按照mro继续往后查找

#A没有继承B,但是A内super会基于C.mro()继续往后找
class A:
    def test(self):
        super().test()
class B:
    def test(self):
        print('from B')
class C(A,B):
    pass

c=C()
c.test() #打印结果:from B

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

父类名.父类方法() 与 super()的区别：

#指名道姓
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        A.__init__(self)

class C(A):
    def __init__(self):
        print('C的构造方法')
        A.__init__(self)

class D(B,C):
    def __init__(self):
        print('D的构造方法')
        B.__init__(self)
        C.__init__(self)

    pass
f1=D() #A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''

#使用super()
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()

class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()

class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super(D,self).__init__()

f1=D() #super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''

当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）

七.选择系统练习——day25