CLASS类继承

单继承：
# class People: 经典类
class People(object): #新式类
    def __init__(self,name,age,n=1000):
        self.name = name
        self.age = age
        self.n = n
        print("--doens't run ")
    def eat(self):
        print("%s is eating..." % self.name)
    def talk(self):
        print("%s is talking..." % self.name)
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Man(People):
    def __init__(self,name,age,money,n=999):    #重构父类初始化方法    #父类的默认参数n 可以不写;调用父类的n
        #People.__init__(self,name,age) #经典类写法      和下面super这行代码的效果一样
        super(Man,self).__init__(name,age) #新式类写法       #调用父类的初始化方法,默认参数n可以不写
        self.n = n          #如果这行不写，也就是不给Man类实例的n属性赋值，默认还是父类n的值
        self.money  = money     #Man类实例自己的一个属性money，不是继承父类的
        print("%s 一出生就有%s money" %(self.name,self.money))
    def sleep(self):
        People.sleep(self)
        print("man is sleeping ")

m1 = Man("NiuHanYang",22,10)
print(m1.n)
------------------------------------------------------------
多继承：

# class People: 经典类
class People(object): #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.friends = []
        print("--doens't run ")
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Relation(object):
    # def __init__(self,n1,n2):
    #     print("init in relation")
    def make_friends(self,obj): #obj 传递的是实例
        print("%s is making friends with %s" % (self.name,obj.name))
        self.friends.append(obj)    #obj存储的是一个实例的地址,friends 指向那个实例的地址，这样不管实例中数据如何更改，friends都是读取的是实例中的数据       #不要append(obj.name) 因为这样存的是一个字符串，如果内存中obj.name更改了， friends列表没有更改，这样数据都不一致了；

class Man(Relation,People):   #继承多个类  #Relation和People      实例初始化的时候只会调用第一个Relation类的初始化方法，如果第一个Relation类中没有初始化方法才会找People的__init__初始化方法，按照继承的顺序找的
    def __init__(self,name,age,money):
        # People.__init__(self,name,age) #经典类写法         #指定调用People的初始化方法
        super(Man,self).__init__(name,age) #新式类写法               #这样写只会调用Relation的__init__初始化函数，
        self.money  = money
        print("%s 一出生就有%s money" %(self.name,self.money))
    def sleep(self):
        People.sleep(self)
        print("man is sleeping ")
class Woman(People,Relation):
    def get_birth(self):
        print("%s is born a baby...." % self.name)

m1 = Man("NiuHanYang",22,10)    #先执行Relation的__init__初始化函数，再执行Man自己的__init__初始化函数，不执行People的__init__初始化函数， 如果没有初始化函数跳过不执行;
　　　　　　　　　　　　　　　　　　 #如果第一个Relation类中没有初始化方法才会找People的__init__初始化方法，按照继承的顺序找的
w1 = Woman("ChenRonghua",26)
m1.make_friends(w1)
w1.name = "陈三炮"
# print(m1.friends[0])
print(m1.friends[0].name)
print(m1.friends[0].age)
m1.make_friends(w1)

------------------------------------------------------------

super初始化说明：
class A(object):
    def __init__(self,name):
        self.name_1 =  name
    pass
class B(object):
    def __init__(self,name):
        self.name = name

class C (A,B):      #先继承A，然后再继承B
    def  __init__(self,name):
        super(C,self).__init__(name)

d = C('alex')
print(d.name_1)     #输出alex
# print(d.name)       # 报错:'C'对象没有属性'name'

#继承多个类，按照继承顺序(从左到右)调用第一个类的_init__初始化方法，第一个类没有初始化方法会找第二个类的初始化方法，依次类推；不仅仅是初始化方法，别的方法实例调用也是一样的；

super类功能：新式类实现广度优先的不重复的调用父类，解决了钻石继承（多继承）的难题

------------------------------------------------------------

class A(object):       #新式类
#class A:              #经典类
    def __init__(self):
        print("A")
class B(A):
    pass
    # def __init__(self):
    #     print("B")
class C(A):
    pass
    def __init__(self):
        print("C")
class D(B,C):
    pass
    # def __init__(self):
    #     print("D")

obj = D()

继承
py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的
py3 经典类和新式类都是统一按广度优先来继承的

广度优先查找顺序是D->B->C->A;深度优先查找顺序是D->B->A-C; 广度优先 是 横向查找B没有查找B同级的C，深度优先 是 纵向查找B没有查找B的父类A;

注意：是所有方法，不仅仅是初始化方法；

新式类，经典类主要区别是在多继承；

参考：
https://www.cnblogs.com/attitudeY/p/6789370.html
https://www.cnblogs.com/xinghuaikang/p/8481712.html