继承与派生

　　今天学习了继承与派生

　　一、继承

　　　　继承是一种创建新类的方式，新建的类可以继承一个或多个父类（Python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。

　　　　子类会‘遗传’父类的属性，从而解决代码重用问题

　　　　python中类的继承分为：单继承和多继承

　　　　

class PatenClass1:    #定义父类
    pass

class ParentClass2:    #定义父类
    pass

class SubClass1(ParentClass1):    #单继承，基类是ParenClass1,派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承

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

经典类与新式类

1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.在python2中，没有显示的继承object类的类，以及该类的子类，都是经典类
3.在python2中，显示的声明继承object的类，以及该类的子类，都是新式类
4.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法(如__str__)的实现。

　　二、继承与抽象(先抽象再继承)

　　　　继承描述的是子类与父类之间的关系，是一种什么是什么的关系。要找出这种关系，必须先抽象再继承

　　　　抽象即抽取类似或者说比较像的部分。

　　　　继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

　　　　抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。

　　三、继承与重用性

　　　　在开发程序的过程中，如果我们定义了一个类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)
r1.attack(g1)
print(g1.life_value)

'''
运行结果
243
'''

　　　　提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大省了编辑工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就大大缩短了软件开发周期，对大型软件开发来说意义重大

　　四、派生

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

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.atack(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
比基尼
'''

　　五、继承实现的原理（可恶的菱形问题）

　　　　1 继承顺序

　　　　在Java和c#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如A（B，C，D）

　　　　如果继承关系为非菱形结构，则会按照先找B这一条分支，然后再找C这一条分支，最后找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):
    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')

f1 = F()
f1.test()
print(F.__mro__)　　#只有新式才有这个属性可以查看线性列表，经典类没有这个属性

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

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

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

>>> F.mro()    #等同于F.__mro__
[<class '__init__.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):    #地铁
    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(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()

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