day25 python学习 继承，钻石继承 多态

---恢复内容开始---

通过一个列子认识父类和子类中，子类的如何实现对父类默认属性调用，同时拥有自己的属性，
如何在子类中调用父类的方法，
class Ainmal:
    country='afdas'
    def __init__(self,name,life_value,argg):
        self.name=name
        self.life_value=life_value
        self.argg=argg
    def eat(self):
        self.life_value+=10
    def equipment(self):
        self.argg+=50
class Dog(Ainmal):
    def __init__(self,name,breed,lief_value,argg):#使用父类的属性，指名道姓用法
        self.breed=breed  #派生属性，父类没有的属性
        #Ainmal.__init__(self,name,lief_value,argg)#这里的参数位置一定要和类的位置一样
        super().__init__(name,lief_value,argg) #新式类#这个方法和上边的方法一样，但是他是寻找最近的父类这个是
    def eat(self):#
        print('狗在吃屎')  # 子类自己的方法
        Ainmal.eat(self)#放在这里可以执行就也可以同时执行父类的放法
        #super(Dog, self).eat()#与上一句的作用一样，也可以写成这种形式super().eat()
    def get_weapon(self):#派生方法：子类中有但是父类中没有的方法
        print('狗得到了武器，准备打人')
sonbyy=Dog('太白','哈士奇',1000,50)
print(sonbyy.eat)
print(Ainmal.eat)
print(sonbyy.life_value)
sonbyy.eat()
print(sonbyy.life_value)
print(sonbyy.__dict__)
#当子类父类都有eat方法的时候，想要调用某一个方法的时候
sonbyy.eat()#狗在吃屎#调用子类的方法

Ainmal.eat(sonbyy)  #调用父类的方法
print(sonbyy.life_value)#

Ainmal.equipment(sonbyy)#  当父类中有的方法，子类没有但是想要调用，可以用此方法进行调用
print(sonbyy.argg) #100 #可以看到对象sonbyy的攻击力增加了

# 人类 狗类 相同的属性 提取了一个__init__方法，在这个方法里放一些共有的属性
# 猫类和狗类 相同的方法 直接把相同的方法提取出来，放在基类里

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师

钻石继承

继承顺序

class D(object):
    def t1(self):
        print('D')
class B(D):
    pass
    # def t1(self):
    #     print('b')
class C(D):
    pass
    # def t1(self):
    #     print('C')
class A(B,C):
    # def t1(self):
    #     print('A')
    pass
f1=A()
f1.t1()  #执行这个的时候，当对象中没有此方法的时候，会先去从父类B中去找有没有t1()方法，
# 没有的话再去父类D中去找，如果还没有的话就去大父类中去找f1()这个方法，
#这就是钻石继承的顺序
print(A.mro())#新式类可以用此方法打印继承顺序如下
#[<class '__main__.A'>, <class '__main__.B'>
# , <class '__main__.C'>, <class '__main__.D'>, <class 'object'>]

#当大父类是class D(object):的新式类而不是class D：这种经典类类型
#的时候,当执行

新式类的继承顺序，广度优先

新式类广度优先

经典类广度优先

继承原理

python到底是如何实现继承的，对于你定义的每一个类，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列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

继承小结

在python2.n的版本中有经典类（class  A:)和            新式类  class A(objiect)   这两种，   区别在于是否是继承objiect

而在Python3.n中，全是新式类（class A:)    不写objiect也是继承objiect       所以在继承关系上全是广度优先

# 在多继承中，super不只是寻找当前类的父类，而是依据mro顺序，
# 从A节点出发，根据广度优先排序查找下一个类

继承的作用

减少代码的重用
提高代码可读性
规范编程模式

几个名词

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

抽象类与接口类

还未讲呢

1.多继承问题
在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口

2.方法的实现
在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

钻石继承

新式类：广度优先
经典类：深度优先

多态

多态 & 鸭子类型
# 一种事物的多种形态
# class Animal：pass
# class Dog(Animal):pass
# class Cat(Animal):pass

多态性

一 什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

多态性

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

---恢复内容结束---