面向对象三大特性——继承（含派生）

1、继承概念

　　继承指的是类与类之间的关系，继承的功能之一就是能够用来解决代码重用问题。

一、继承是什么？

（1）继承是一种建立新类的方式

（2）在python中，新建的类能够继承一个或多个父类（其余语言只能继承一个父类），父类又能够称为基类或者超类

（3）新建的类称为派生类或子类。

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

class ParentClass1:
    pass

class ParentClass2:
    pass

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

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

三、查看继承: __bases__ 

　　__base__：只查看从左到右继承的第一个子类
　　__bases__：查看全部继承的父类

print(ParentClass1.__base__, type(ParentClass1.__base__))
print(SubClass1.__base__, type(SubClass1.__base__))
print(SubClass2.__base__, type(SubClass2.__base__))   # 只查看到第一个父类
"""
<class 'object'> <class 'type'>
<class '__main__.ParentClass1'> <class 'type'>
<class '__main__.ParentClass1'> <class 'type'>
"""

print(SubClass1.__bases__)
print(SubClass2.__bases__)
"""数据结构为元组
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
"""

四、经典类与新式类

（1）python2中的经典类和新式类

　　经典类：没有显式继承object类的类，以及该类的子类都是经典类。

　　新式类：显式地声明继承object类，以及该类的子类都是新式类。

# Python2中经典类：没有继承object的类，以及它的子类
class Foo:
    pass

class Bar(Foo):
    pass

# python2中新式类：继承object的类，以及它的子类都称为新式类
class Foo(object):
    pass

class Bar(Foo):
    pass
"""
>>> class Foo:pass
...
>>> Foo.__bases__
()
>>> class Foo(object):pass
...
>>> Foo.__bases__
(<type 'object''>,)
"""

（2）python3只有新式类

　　仅在python2中才分新式类和经典类，在python3中，不管是否继承object，都默认继承object，即python3中全部类均为新式类。

　　提示：若是没有指定基类，python的类会默认继承object类，object是全部python类的基类，它提供了一些常见方法（如__str__）的实现。

# python3中新式类：一个类没有继承object类，默认就继承object
class Foo():
    pass

print(Foo.__bases__)     # (<class 'object'>,)

2、继承与抽象（先抽象再继承）

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

一、抽象概念

抽象定义即抽取相似或者说比较像的部分（也就是提取一类事物的特色，范围愈来愈大，共性愈来愈少）。

抽象分为两个层次：
（1）将奥巴马和梅西这俩对象比较像的部分抽取成类；
（2）将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的做用是划分类别（能够隔离关注点，下降复杂度）

　　

二、继承与抽象关系

　　继承：是基于抽象的结果，经过编程语言去实现它，确定是先经历抽象这个过程，才能经过继承的方式去表达出抽象的结构。
　　抽象：只是分析和设计的过程当中，一个动做或者说一种技巧，经过抽象能够获得类。

class Hero:
    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        enemy.life_value -= self.aggresivity

class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1 = Garen('刚哥', 29, 30)
print(g1.__dict__)
"""
{'nickname': '刚哥', 'life_value': 29, 'aggresivity': 30}
"""

3、继承与重用性

　　开发程序的过程当中，若是咱们定义了一个类A，而后又想新创建另一个类B，可是类B的大部份内容与类A的相同时：

　　能够经过继承的方式新建类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

代码重用示例

　　用已经有的类创建一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大节省了编程工做量，这就是常说的软件重用，不只能够重用本身的类，也能够继承别人的，好比标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来讲，意义重大.

一、属性查找

　　子类有本身的方法，就执行本身的；若是子类没有本身的方法，就会找父类的。

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

    def f2(self):
        print('from Foo.f2')
        self.f1()


class Bar(Foo):
    def f2(self):
        print('from Bar.f2')

b = Bar()
print(b.__dict__)  # 未定义__init__没有本身的属性  字典内为空
b.f1()   # 指向父类的函数
b.f2()   # 指向子类重用的函数
"""
{}
from Foo.f1
from Bar.f2   # 注意和父类中的区别
"""

4、派生

一、派生概念

　　在父类的基础上产生子类，产生的子类就叫作派生类

二、方法重写与派生方法

　　父类里有，子类也有的方法，就叫作方法的重写（就是把父类里的方法重写）

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

　　父类里没有的方法，在子类中有了，这样的方法就叫作派生方法。

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
比基尼

'''