继承与派生

小灰灰 2021-03-29 13:04 558阅读 0赞

## 继承 ##

*  继承指的是类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题
 *  继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，新建的类称为派生类或子类

#### python继承分为单继承与多继承 ####

class ParentClass1: #定义父类
        pass
    
    class ParentClass2: #定义父类
        pass
    
    class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
        pass
    
    class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
        pass

**查看继承**

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
    (<class '__main__.ParentClass1'>,)
    >>> SubClass2.__bases__
    (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

**经典类与新式类**

*  只有在python2中才分新式类和经典类，python3中统一都是新式类
 *  在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
 *  在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
 *  在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类  
    **如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如\_\_str\_\_）的实现。**

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

## 继承与抽象（先抽象再继承） ##

抽象即抽取类似或者说比较像的部分  
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度  
[![1226526-20180606123549703-206012931.png][]][1226526-20180606123549703-206012931.png]  
**继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构**  
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类  
[![1226526-20180606123550456-742404606.png][]][1226526-20180606123550456-742404606.png]

## 继承与重用性 ##

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时

我们不可能从头开始写一个类B，这就用到了类的继承的概念。

通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

class Hero:
        def __init__(self,nickname,aggressivity,life_value):
            self.nickname=nickname
            self.aggressivity=aggressivity
            self.life_value=life_value
    
        def move_forward(self):
            print('%s move forward' %self.nickname)
    
        def move_backward(self):
            print('%s move backward' %self.nickname)
    
        def move_left(self):
            print('%s move forward' %self.nickname)
    
        def move_right(self):
            print('%s move forward' %self.nickname)
    
        def attack(self,enemy):
            enemy.life_value-=self.aggressivity
    class Garen(Hero):
        pass
    
    class Riven(Hero):
        pass
    
    g1=Garen('草丛伦',100,300)
    r1=Riven('锐雯雯',57,200)
    
    print(g1.life_value) #结果:300
    r1.attack(g1)
    print(g1.life_value) #结果:243

#### 属性查找 ####

像g1.life\_value之类的属性引用，会先从实例中找life\_value然后去类中找，然后再去父类中找...直到最顶级的父类。那么如何解释下面的打印结果呢？

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
    #这先在b对象里查找，然后再到bar类里查找，如还没有就去父类查找，父类里有先打印foo.f2，self.f1实际上还是调用b.f1，所以打印的就是这#样的结果

## 派生 ##

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

class Riven(Hero):
        camp='Noxus'
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)

在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值

class Riven(Hero):
        camp='Noxus'
        def __init__(self,nickname,aggressivity,life_value,skin):
            Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
            self.skin=skin #新属性
        def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
            Hero.attack(self,enemy) #调用功能
            print('from riven')
        def fly(self): #在自己这里定义新的
            print('%s is flying' %self.nickname)
    
    r1=Riven('锐雯雯',57,200,'比基尼')
    r1.fly()
    print(r1.skin)
    
    '''
    运行结果
    锐雯雯 is flying
    比基尼
    
    '''

## 继承的实现原理 ##

对于定义的每一个类，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列表并遵循如下三条准则:

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

#### 继承查找主要分为深度优先与广度优先 ####

##### 当类是经典类时，查找方法为深度优先 #####

#### 当类是新式类时，为广度优先 ####

示例：

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__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
    
    #新式类继承顺序:F->D->B->E->C->A
    #经典类继承顺序:F->D->B->A->E->C
    #python3中统一都是新式类
    #pyhon2中才分新式类与经典类

## 在子类调用父类的方法 ##

一、指名道姓，即父类名.父类方法（）

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): #地铁
        def __init__(self,name,speed,load,power,line):
            Vehicle.__init__(self,name,speed,load,power)#调用父类方法
            self.line=line
    
        def run(self):
            print('地铁%s号线欢迎您' %self.line)
            Vehicle.run(self)
    
    line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
    line13.run()

二、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): #地铁
        def __init__(self,name,speed,load,power,line):
            #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
            super().__init__(name,speed,load,power)
            self.line=line
    
        def run(self):
            print('地铁%s号线欢迎您' %self.line)
            super(Subway,self).run()
    
    class Mobike(Vehicle):#摩拜单车
        pass
    
    line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
    line13.run()

这两种方式的区别是：方式一是跟继承没有关系的，而方式二的super()是依赖于继承的，并且即使没有直接继承关系，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'>]
````
<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">
````

[1226526-20180606123549703-206012931.png]: /images/20210329/1617023320658.png
[1226526-20180606123550456-742404606.png]: /images/20210329/1617023280374.png