python's twenty day for me 继承 和 super()方法

super():

　　在单继承中就是单纯的寻找父类。

　　在多继承中就是根据子节点所在图 的mro顺序，找寻下一个类。

遇到多继承和super()：

　　对象.方法

　　　　1，找到这个对象对应的类。

　　　　2，将这个类的所有父类都找到换成一个图。

　　　　3，根据图写出广度优先的顺序。

　　　　4，再看代码，根据广度优先，来找super().

# 在python 3x 中
class A:
    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')

d = D()
d.func()

 钻石继承：深度优先。

　　　mro()    子类名.mro()

　　经典类：在python2x版本才存在，且必须不继承object。python3x中默认继承object所以都是新式类。

　　经典类：

　　　　1，遍历的时候遵循深度优先算法。

　　　　2，没有 mro() 方法。

　　　　3，没有 super()方法。

　　新式类：在python2x中需继承object才是新式类。

　　　　1，遍历的时候遵循广度优先算法。

　　　　2，有 mro() 方法。

　　　　3，有super() 方法，但是在python2x中必须传参数（子类名.子类对象名）

 

# 在python2x中
# coding:utf-8

class A(object):
    def func(self):
        print('A')
class B(A):
    pass
    def func(self):
        # super(B,self).func()
        print('B')
class C(A):
    pass
    def func(self):
        # super(C,self).func()
        print('C')
class D(B,C):
    pass
    def func(self):
        # super(D,self).func()
        print('D')
d = D()
d.func()
print(D.mro())  # [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>]

 

继承与派生：

　　子类会继承父类的所有方法，前提子类没有相同的方法名。

class Animal:
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('eating in Animal')
        self.hp += 20

class Person(Animal):
    def __init__(self,name,hp,ad,sex):   # 重写
        super().__init__(name,hp,ad)       # 在单继承中，super负责找到当前类所在的父类，在这个时候不需要再手动传self
        self.sex = sex      # 派生属性
        self.money = 100
    def attack(self,dog):       # 派生方法
        print('%s攻击了%s' % (self.name,dog.name))
    def eat(self):          # 重写
        super().eat()       # 在类内 使用super()方法着父类方法
        print('eating in Person')
        self.money -= 50

class Dog(Animal):
    def __init__(self,name,hp,ad,kind):
        super().__init__(name,hp,ad)
        self.kind = kind        # 派生属性
    def bite(self,person):      # 派生属性
        person.hp -= self.ad

alex = Person('alex',100,10,'female')
print(alex.__dict__)

# 父类有eat 子类没有。
# alex.eat()  # 找父类的。
# alex.eat()  #子类有eat() 不管有没有都会先找子类的。
# 当子类中有，但是想要调用父类的方法。
# Animal.eat(alex)          # 指名道姓
# super(Person,alex).eat()      #super(子类名，子类对象名) 方法。 

 多继承：

　　新式类，多继承，寻找名字的顺序，遵循广度优先。

class A:
    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')

d = D()
d.func()