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

巴特西

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

super():

遇到多继承和super()：

钻石继承：深度优先。

继承与派生：

多继承：

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

最新文章

热门文章

巴特西

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

super():

遇到多继承和super()：

钻石继承：深度优先。

继承与派生：

多继承：

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

最新文章

热门文章

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

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