Python全栈学习笔记day 24：单继承、派生、super()、多继承

一、继承

class A:pass            父类，基类，超类
class B:pass            父类，基类，超类
class AB_son(A,B):pass   子类，派生类
class A_son(A):pass    子类，派生类


print(A_son.__bases__)         (<class '__main__.A'>,)
print(AB_son.__bases__)        (<class '__main__.A'>, <class '__main__.B'>)
print(A.__bases__)             (<class 'object'>,)

__bases__  查看继承的父类

一个类可以被多个类继承，一个类可以继承多个父类，没有继承父类默认继承object

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

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

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

人狗大战的栗子：

class Animal:
    '''
    人和狗都是动物，所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name                   人和狗都有自己的昵称;
        self.aggressivity = aggressivity   人和狗都有自己的攻击力;
        self.life_value = life_value       人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    pass

class Person(Animal):
    pass

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
egg.eat()
ha2.eat()

二、派生

1、父类中没有的属性 在子类中出现 叫做派生属性
2、父类中没有的方法 在子类中出现 叫做派生方法
3、只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
4、如果父类、子类都有就用子类的
   如果还想用父类的，单独调用父类的:
          父类名.方法名 需要自己传self参数
          super().方法名 不需要自己传self
5、正常的代码中 单继承 == 减少了代码的重复

人狗大战中派生的栗子（看栗子就懂了）：在子类中使用父类中的__init__方法一：

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp

    def eat(self):
        print('吃药回血')
        self.hp+=100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)     使用父类中的__init__方法一，切记要穿参数self
        self.kind = kind                    派生属性
    def eat(self):
        Animal.eat(self)      如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类，切记要穿参数self
        self.teeth = 2
    def bite(self,person):                   派生方法
        person.hp -= self.aggr

jin = Dog('金老板',100,500,'吉娃娃')
jin.eat()
print(jin.hp)

三、了解super()

（看栗子就懂了）：在子类中使用父类中的__init__方法二：

class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)   使用父类中的__init__方法二，只在新式类中有，python3中所有类都是新式类
        self.kind = kind                 派生属性
    def eat(self):print('dog eating')

jin = Dog('金老板',200,500,'teddy')
print(jin.name)
jin.eat()
super(Dog,jin).eat()         super(子类，对象).父类中药继承的方法

四、多继承

单继承 ： 子类有的用子类 子类没有用父类
多继承中，我们子类的对象调用一个方法，默认是就近原则，
经典类中 深度优先
新式类中 广度优先
python2.7 新式类和经典类共存，新式类要继承object
python3   只有新式类，默认继承object
经典类和新式类还有一个区别  mro方法只在新式类中存在
super 只在python3中存在
super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

4.1  钻石继承

理解super：

class A(object):
    def func(self): print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')
b = D()
b.func()
print(B.mro())



A
C
B
D
[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

总结：

抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承：子类继承了父类的方法和属性
派生：子类在父类方法和属性的基础上产生了新的方法和属性