day 24-1 继承

继承

什么是继承：
　　继承是一种创建新类的方式，在 python 中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

父类必须在子类上面
　　一个类 可以被多个类继承
　　一个类 可以继承多个父类 —— python 里

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

print(A_son.__bases__)  #查看 A_son 继承了谁，查看父类用的
print(AB_son.__bases__)
print(A.__bases__)  #在 python 中任何一个没有父类的类都是 object 类的儿子（类的祖宗）
print(B.__bases__)  # python3 -新式类 #没有继承父类默认继承 object

单继承 *****

人狗大战

可以发现下面有共同属性

#可以发现下面有共同属性
class Person:
    def __init__(self,name,hp,aggr,sex):
        self.name = name
        self.hp = hp
        self.aggr = aggr
        self.sex = sex

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

接下来我们把重复代码提出出来 —— 单继承

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

class Person(Animal):
    def __init__(self,name,hp,aggr,sex):
        Animal.__init__(self,name,hp,aggr)
        self.sex = sex    #派生属性
    def attack(self,dog): #派生方法
        dog.hp -= self.aggr

class Dog(Animal):
     def __init__(self,name,hp,aggr,kind):
        Animal.__init__(self,name,hp,aggr)
        self.kind = kind  #派生属性
     #假如说 dog 吃药后，还想加点攻击力
     def eat(self):       #派生方法
         Animal.eat(self) #与调用父类中的方法相结合
         self.aggr += 15

#然后实例化
per = Person('无极',200,30,'男')
dog = Dog('二哈',200,15,'Poodle')
#print(per.__dict__) #查看继承的属性
#print(dog.__dict__)

per.attack(dog)
print(dog.hp)
dog.eat()
print(dog.hp,dog.aggr)

派生

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

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

super 的用法
　　只在新式类中有，python3 中所有类都是新式类
　　在类中使用 不需要传 self 参数，在类外使用必须要传 类 和 对象
　　查找自己所在类的父类

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

class Person(Animal):
    def __init__(self,name,hp,aggr,sex):
        #Animal.__init__(self,name,hp,aggr)
        super().__init__(name,hp,aggr) #不需要传 self 了,对于单继承 super 就可以找到父类了
        self.sex = sex  #派生属性
per = Person('凯子',500,20,'男')
print(per.__dict__)
#也可以在类外用
#传一个 类 和一个 对象
super(Person,per).eat()
print(per.hp) #原本是 500

多继承 ***

class A:
    def func(self):
        print("A")

class B:
    def func(self):
        print("B")

class C:
    def func(self):
        print("C")

class D(A,B,C):  #调用是从左向右的顺序
    pass
    #def func(self):  #这里注释掉调用的就是 A
     #   print('D')

d = D()
d.func()

钻石继承问题

遵循广度优先（适用于多个继承都可以找到 A 时） 然后在找深度
新式类中的继承顺序 ： 广度优先

class A:
    def func(self):
        print("A")

class B(A):           #2.这里也注释掉调用的是 C
    pass
    #def func(self):
     #   print("B")

class C(A):           #3.这里也注释掉调用的是 A
    pass
    #def func(self):
     #   print("C")

class D(B,C):
    pass
    #def func(self):  #1.这里注释掉调用的是 B
     #   print('D')

d = D()
d.func()
print(D.mro()) #记录了继承关系

super 的多继承问题
　　super 的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的
　　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()

小结：

继承 ： 什么是什么的关系
单继承 *****
　　先抽象再继承，几个类之间的相同代码抽象出来，成为父类
　　子类自己没有的名字，就可以使用父类的方法和属性
　　如果子类自己有，一定是先用自己的
　　在类中使用 self 的时候，一定要看清楚 self 指向谁
多继承 ***
　　新式类和经典类：
　　　　多继承寻找名字的顺序 ： 新式类广度优先，经典类深度优先
　　　　新式类中 有一个类名 .mro 方法，查看广度优先的继承顺序
　　　　python3 中有一个 super 方法，根据广度优先的继承顺序查找上一个类

2.7
新式类 继承 object 类的才是新式类 广度优先
经典类 如果你直接创建一个类在 2.7 中就是经典类 深度优先
print(D.mro())
D.mro()

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