标签：母亲 直接 for color tips 检查 继承 简单的 play
一个子类继承多个父类，就是多继承，并且拥有所有父类的属性和方法
例如：孩子会继承父亲和母亲的特征
如果子类和父类中有相同的方法，就会调用子类中的方法
如果不同的父类中存在有相同的方法名称，子类对象调用的时候会调用哪个父类中的方法呢？
python 会根据MRO(method resolution order) 方法解析顺序列表进行查找。
class Dog: def eat(self): print("吃骨头") class God: def eat(self): print("吃上帝") class Thing(God,Dog): pass thing = Thing() thing.eat() print(Thing.__mro__) # 吃上帝 # (<class ‘__main__.Thing‘>, <class ‘__main__.God‘>, <class ‘__main__.Dog‘>, <class ‘object‘>)
MRO列表并遵循如下三条准则：
1.子类会先于父类被检查
2.多个父类会根据他们在列表中的顺序进行检查
3.如果对下一个类中有两个合法的选择，选择第一个父类
class A: def func(self): print("----A----") class B(A): def func(self): print("----B----") class C(A): def func(self): print("----B-----") class D(B,C): pass d = D() d.func() print(D.__mro__) print(D.mro()) # ----B---- # (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>) # [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
多继承中super本质不是直接查找父类，而是根据调用节点的广度优先顺序执行的
练习：创建 A、B、C、D 类，D 类继承 B,C 类，B 类继承 A 类，C 类继承 A 类。
在每个方法中都调用 super().func()方法，查看执行顺序。
class A: def func(self): print("----A----") class B(A): def func(self): super(B, self).func() print("----B----") class C(A): def func(self): super(C, self).func() print("----C-----") class D(B,C): def func(self): super(D, self).func() print("----D-----") d = D() d.func() # 继承顺序 D-->B-->C-->A #结果：A,C,B,D print(D.__mro__) print(D.mro()) # (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>) # [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
如图，B 继承 A， C 继承 A， D 继承 B 和 C。
深度优先遍历是从 D 开始往上搜索到 B，若 B 没有数据，则继续往上搜索到 A；
广度优先遍历是从 D 开始往上搜索到 B，若 B 没有数据，则搜索和 B 同级的 C 里的数据，若同级的 C 里还是没有数据，再继续往上搜索到 A 。
Tips：py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的。
py3 经典类和新式类都是统一按广度优先来继承的
class A: def func(self): print("----A----") class B(A): def func(self): super(B, self).func() print("----B----") class C(A): def func(self): super(C, self).func() print("----C-----") class D(B): def func(self): super(D, self).func() print("----D-----") class E(C): def func(self): super(E, self).func() print("----E-----") class F(D, E): def func(self): super(F, self).func() print("----F-----") f = F() f.func() # 继承顺序 D-->B-->C-->A # ----A---- # ----C----- # ----E----- # ----B---- # ----D----- # ----F-----
class A: def func(self): print("----A----") class B(A): def func(self): super(B, self).func() print("----B----") class C(A): def func(self): super(C, self).func() print("----C-----") class D(C): def func(self): super(D, self).func() print("----D-----") class E(B): def func(self): super(E, self).func() print("----E-----") class G(B): def func(self): super(G, self).func() print("----G-----") class H(A): def func(self): super(H, self).func() print("----H-----") class F(D, E,G,H): def func(self): super(F, self).func() print("----F-----") f = F() f.func() # ----A---- # ----H----- # ----B---- # ----G----- # ----E----- # ----C----- # ----D----- # ----F-----
class A1: pass class A2: pass class A3: pass class B1(A1,A2): pass class B2(A2): pass class B3(A2,A3): pass class C1(B1): pass class C2(B1,B2): pass class C3(B2,B3): pass class D(C1, C2, C3): pass print("从D开始查找：") for s in D.__mro__: print(s) # 从D开始查找： # <class ‘__main__.D‘> # <class ‘__main__.C1‘> # <class ‘__main__.C2‘> # <class ‘__main__.B1‘> # <class ‘__main__.A1‘> # <class ‘__main__.C3‘> # <class ‘__main__.B2‘> # <class ‘__main__.B3‘> # <class ‘__main__.A2‘> # <class ‘__main__.A3‘># <class ‘object‘>
面向对象三大特性： 封装、继承、多态
1.封装：屏蔽提供细节，但提供调用方式，将功能封装成一个整体，提供简单的调用方式
2.继承：可以拥有另一个类的方法和属性
3.多态：让某个类呈现多种形态
实现多态的三个条件： 1.必须存在继承关系 2.重写目标方法 3.使用子类对象调用父类方法
定义人类，可以跳舞，可以玩，在玩的过程跳舞
实现多态，老年人跳广场舞
class Person: def dance(self): print(‘跳舞‘) def play(self): self.dance() #old.dance() class Oldman(Person): def dance(self): print("跳广场舞") old = Oldman() old.play() per = Person() per.play()
标签：母亲 直接 for color tips 检查 继承 简单的 play
原文地址：https://www.cnblogs.com/johnsonbug/p/12708027.html
