通过一个列子认识父类和子类中，子类的如何实现对父类默认属性调用，同时拥有自己的属性，如何在子类中调用父类的方法，class Ainmal:country='afdas'def __init__(self,name,life_value,argg):self.name=nameself.life_value=life_valueself.argg=arggdef eat(self):self.life_value+=10def 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)#1030

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：这种经典类类型
#的时候,当执行

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

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

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

还未讲呢

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()