面向对象单双继承

⾯向对象单双继承什么是继承：
继承是⼀种创建新类的⽅式，在python中，新建的类可以继承⼀个或多个⽗类，
⽗类⼜可称为基类或超类，新建的类称为派⽣类或⼦类。

python中类的继承分为：单继承和多继承：
class ParentClass1: #定义⽗类
pass
class ParentClass2: #定义⽗类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派⽣类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python⽀持多继承，⽤逗号分隔开多个继承的类pass
#多继承
class A1: #⽗类(<class 'object'>,)
pass
class A2: #⽗类(<class 'object'>,)
pass
class B1: #(⽗类<class 'object'>,)
pass
class B2(B1,A1,A2): #⼦类继承了(B1,A1,A2):
pass
print(B2.__bases__) #B2继承了 __B1__, __A1__, ___A2__
##class '__main__.B1'>, <class '__main__.A1'>, <class '__main__.A2'>)
(<class 'object'>,)
2个类继承⼀个⽗类例⼦：
class an:#⽗类共同属性
def __init__(self,name,aggr,hp):#⽅法动态属性内置的双下⽅法
= name 对象属性实例化属性
self.aggr = aggr
self.hp = hp
def eat(self):###独⽴函数
print('in an eat')
class Dog(an): #Dog继承了“an”这个类
def __init__(self,kind,name,aggr,hp):
self.kind = kind #Dog这个类中单独有的属性 # 派⽣⽅法
# super().__init__(name,aggr,hp) #
an.__init__(self,name,aggr,hp)
def eat(self):
print('in dog eat')
class peron(an):#peron 这个⼦类继承了“an”这个⽗类
def __init__(self,sex,name,aggr,hp):
self.sex =sex #派⽣⽅法
# super().__init__(name,aggr,hp)
#单继承中 super（）会寻找⽗类
#⽽且在使super调⽤⽗类⽅法适合不要再给传self参数
an.__init__(self,name,aggr,hp)
def eat(self):
print('in peron eat')
alex = peron('男','alex',20,100) # ⼦类使⽤名字(⽅法和静态变量),如果在⼦类中没有,就使⽤⽗类的\
# Cat('Tom','暹罗猫','猫粮') 实例化
# 实例化这个类
#创建⼀个空对象
# 执⾏__init__⽅法:⼦类没有⽤⽗类的
peron.eat() #调⽤了peron这个类的 eat()函数
super(peron,alex).eat()
an.eat(alex) #调⽤了an这个⽗类的 eat()函数把alex传⼊进去
print(alex.aggr)
print(alex.sex)
hei = Dog('咬⼈','⿊',20,1000)
print()
print(hei.kind)
单继承多次按类的顺序依次集成：
class A:
def wahaha(self):print('in A')
class B(A): #class B 继承了A
def wahaha(self):print('in B')
class C(B):pass #class C 继承了B
def wahaha(self):print('in C')
class D(C):pass #class D 继承了C
# def wahaha(self):print('in D')
#d = D()
d.wahaha()
钻⽯继承问题：
# coding:utf-8
class A: #A类
def wangwang(self):
print('in A')
class B(A): #B类继承A类
def wangwang(self):
super().wangwang() # 'in C ' 如果C ,D中都找不到就会找B把 “in B” 打印出来，但是同时有了super，super还会找上级也就是A print('in B')
class C(A): #C类也继承A类
def wangwang(self):
print('in C')
class D(B,C):pass#D类继承B和C类 D类的d.wangwang。

没有去B找如果B⾥⾯没有去C找如果全都没有后那就去A找，但是如果其中加了suerp（）在有2个或者多个的类⾥⾯他会先按光度查找，如果在单个的类⾥⾯他会直接先找⽗级
d = D()） #D()类加括号后赋值给d后执⾏这个类名，没有了d.wangang 后开始找上⼀级
d.wangwang() #找D类中的wangwang()
py3 super
# 单继承中 super就是找⽗类
# 多继承 super寻找的轨迹是根据mro(⼴度优先)顺序的
在py3⾥所有的多继承问题都符合⼴度优先算法：
如果⼀个类继承了object 这个类就被称为新式类，在2.7中没有继承object类就被称为经典类。

度优先⼴度优先都是⼀种遍历算法,把这个图中所有的项都⾛⼀遍,且不会重复
那么问题⼜来了，多继承呢？
是否可以继承多个类
如果继承的多个类每个类中都定了相同的函数，那么那⼀个会被使⽤呢？
1、Python的类可以继承多个类，Java和C#中则只能继承⼀个类
2、Python的类如果继承了多个类，那么其寻找⽅法的⽅式有两种，分别是：深度优先和⼴度优先
当类是经典类时，多继承情况下，会按照深度优先⽅式查找
当类是新式类时，多继承情况下，会按照⼴度优先⽅式查找
经典类和新式类，从字⾯上可以看出⼀个⽼⼀个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果当前类或者⽗类继承了object类，那么该类便是新式类，否则便是经典类。

经典类：⾸先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是
未找到，则报错
新式类：⾸先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是
未找到，则报错
经典类遵循深度优先算法且没有mro⽅法 python2
新式类遵循⼴度优先算法有mro⽅法 py2 py3
py3 super
# 单继承中 super就是找⽗类
# 多继承 super寻找的轨迹是根据mro(⼴度优先)顺序的。