转 -- Python: 多继承模式下 MRO(Method Resolution Order) 的计算方式关乎super

大家可能已经知道了,在 Python 3(Python 2 的新式类)中多继承模式是使用 C3 算法来确定 MRO(Method Resolution Order) 的。

那么具体是怎么计算的呢?本文将基于 https://www.python.org/downlo... 中的几个例子来讲解 MRO 是怎么计算的。

我们首先来定义一些符号: :

用 CN 表示一个类:C1, C2, C3, ..., CN
C1 C2 C3 ... CN 表示的是一个包含多个类的列表 [C1, C2, C3, ..., CN]
其中: :

head = C1
tail = C2 ... CN
加法运算: :

C + (C1 C2 ... CN) = C C1 C2 ... CN
[C] + [C1, C2, ... ,CN] = [C, C1, C2, ..., CN]
L[C] 表示类 C 的线性值,其实就是 C 的 MRO, 其中 :

L[object] = object
比如有个类 : :

class C(B1, B2, ..., BN): pass
那么: :

L[C(B1 ... BN)] = C + merge(L[B1] ... L[BN], B1 ... BN)
merge 的计算规则如下:

take the head of the first list, i.e L[B1][0]; if this head is not in the tail of any of the other lists, then add it to the linearization of C and remove it from the lists in the merge, otherwise look at the head of the next list and take it, if it is a good head. Then repeat the operation until all the class are removed or it is impossible to find good heads. In this case, it is impossible to construct the merge, Python 2.3 will refuse to create the class C and will raise an exception.

计算 MRO
先从简单的类说起: :

class B(object): pass

L[B] = L[B(object)]
= B + merge(L[object])
= B + L[object]
= B object

B.mro()
[<class ‘main.B‘>, <type ‘object‘>]
简单的子类: :

class C(B): pass

L[C] = L[C(B)]
= C + merge(L[B])
= C + L[B]
= C B object # 从上面已经知道了 L[B] = B object

C.mro()
[<class ‘main.C‘>, <class ‘main.B‘>, <type ‘object‘>]
下面来看一个复杂的例子: :

O = object
class F(O): pass
class E(O): pass
class D(O): pass
class C(D,F): pass
class B(D,E): pass
class A(B,C): pass
很容易就可以想到: :

L[O] = O = object
L[F] = L[F(O)] = F O
L[E] = L[E(O)] = E O
L[D] = L[D(O)] = D O
下面来计算 C, B, A:

L[C]: :

L[C] = L[C(D, F)]
= C + merge(L[D], L[F], DF)
# 从前面可知 L[D] 和 L[F] 的结果
= C + merge(DO, FO, DF)
# 因为 D 是顺序第一个并且在几个包含 D 的 list 中是 head,
# 所以这一次取 D 同时从列表中删除 D
= C + D + merge(O, FO, F)
# 因为 O 虽然是顺序第一个但在其他 list (FO)中不是 head, 跳过,
# 改为检查第二个list FO # F 是第二个 list 和其他 list 的 head,
# 取 F同时从列表中删除 F
= C + D + F + merge(O)
= C D F O

C.mro()
[<class ‘main.C‘>, <class ‘main.D‘>, <class ‘main.F‘>, <type ‘object‘>]
L[B]: :

L[B] = L[B(D, E)]
= B + merge(L[D], L[E], DE)
= B + merge(DO, EO, DE)
= B + D + merge(O, EO, E)
= B + D + E + merge(O)
= B D E O

B.mro()
[<class ‘main.B‘>, <class ‘main.D‘>, <class ‘main.E‘>, <type ‘object‘>]
L[A]: :

L[A] = L[A(B, C)]
= A + merge(L(B), L(C), BC)
= A + merge(BDEO, CDFO, BC)
= A + B + merge(DEO, CDFO, C)
# 注意这里是 C , 因为第一个list 的 head D 不是其他list 的 head
# 所以改为从下一个 list CDFO 开始
= A + B + C + merge(DEO, DFO)
= A + B + C + D + merge(EO, FO)
= A + B + C + D + E + merge(O, FO)
= A + B + C + D + E + F + merge(O)
= A B C D E F O

A.mro()
[<class ‘main.A‘>, <class ‘main.B‘>, <class ‘main.C‘>,
<class ‘main.D‘>, <class ‘main.E‘>, <class ‘main.F‘>, <type ‘object‘>]
到这里应该已经有一点眉目了。下面再来个上面那些类的变种,可以先自己算算看,后面有详细的计算过程。

O = object
class F(O): pass
class E(O): pass
class D(O): pass
class C(D,F): pass
class B(E,D): pass
class A(B,C): pass
跟之前唯一的区别是 B(D, E) 变成了 B(E, D) :

L[O] = O = object
L[F(O)] = F O
L[E(O)] = E O
L[D(O)] = D O

L[C] = L[C(D, F)]
= C + merge(L[D], L[F], DF)
= C D F O

L[B] = L[B(E, D)]
= B + merge(L[E], L[D], ED)
= B + merge(EO, DO, ED)
= B + E + merge(O, DO, D)
= B + E + D + merge(O)
= B E D O

B.mro()
[<class ‘main.B‘>, <class ‘main.E‘>, <class ‘main.D‘>, <type ‘object‘>]

L[A] = L[A(B, C)]
= A + merge(L[B], L[C], BC)
= A + merge(BEDO, CDFO, BC)
= A + B + merge(EDO, CDFO, C)
= A + B + E + merge(DO, CDFO, C)
= A + B + E + C + merge(DO, DFO)
= A + B + E + C + D + merge(O, FO)
= A + B + E + C + D + F + merge(O)
= A B E C D F O

A.mro()
[<class ‘main.A‘>, <class ‘main.B‘>, <class ‘main.E‘>,
<class ‘main.C‘>, <class ‘main.D‘>, <class ‘main.F‘>, <type ‘object‘>]
通过这几个例子应该对如何计算 MRO 已经有所了解了,更详细的信息可以阅读 python MRO 文档 以及 wikipedia 中的 C3 算法.

原文地址:https://www.cnblogs.com/Frank99/p/9240061.html

时间: 2024-10-11 03:51:36

转 -- Python: 多继承模式下 MRO(Method Resolution Order) 的计算方式关乎super的相关文章

Method Resolution Order – Python类的方法解析顺序

在支持多重继承的编程语言中,查找方法具体来自那个类时的基类搜索顺序通常被称为方法解析顺序(Method Resolution Order),简称MRO.(Python中查找其它属性也遵循同一规则.)对于只支持单重继承的语言,MRO十分简单:但是当考虑多重继承的情况时,MRO算法的选择非常微妙.Python先后出现三种不同的MRO:经典方式.Python2.2 新式算法.Python2.3 新式算法(也称作C3).Python 3中只保留了最后一种,即C3算法. 经典类采用了一种简单MRO机制:查

Python进阶-继承中的MRO与super

摘要本文讲述Python继承关系中如何通过super()调用"父类"方法,super(Type, CurrentClass)返回CurrentClass的MRO中Type的下一个类的代理:以及如何设计Python类以便正确初始化. 1. 单继承中父类方法调用 在继承中,调用父类方法是很有必要的.调用父类方法的场景有很多: 比如必须调用父类的构造方法__init__才能正确初始化父类实例属性,使得子类实例对象能够继承到父类实例对象的实例属性: 再如需要重写父类方法时,有时候没有必要完全摒

为Python添加交互模式下TAB自动补全以及命令历史功能

接上篇文章新建Python环境变量配置文件:在宿主用户目录下vim .pystartup# Add auto-completion and a stored history file of commands to your Python# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is# bound to the Esc key by default (you can change it – see

TypeError: Error when calling the metaclass bases Cannot create a consistent method resolution order (MRO) for bases A2, A1 出现原因及其解决办法

原本想测试继承,出现了这个错误: 源代码 1 class A1(object): 2 def fo1(self): 3 print "i'm A1" 4 class A2(object): 5 def fo1(self): 6 print "i'm A2" 7 class B1(A1,A2): 8 def bar(self): 9 print "i'm B1" 10 class B2(A2,A1): 11 def bar(self): 12 pr

python多继承与MRO

所有的函数名都可以理解为变量.python中就不存在类似C++的重载,因为python不允许出现相同的函数名.类的继承中,如果我们重写(overriding)一个函数,那不是重载,这个函数会覆盖父类中的同名函数. C3算法:保证每个类只调用一次 1. 什么是多继承 多继承就是一个类有多个父类. class Mother: pass class Father: pass class Child(Mother, Father): pass issubclass(Child, Mother) and

Python 面向对象继承

一 什么是面向对象的继承 比较官方的说法就是: 继承(英语:inheritance)是面向对象软件技术当中的一个概念.如果一个类别A"继承自"另一个类别B,就把这个A称为"B的子类别",而把B称为"A的父类别"也可以称"B是A的超类".继承可以使得子类别具有父类别的各种属性和方法,而不需要再次编写相同的代码.在令子类别继承父类别的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类别的原有属性和方法,使其获得与父类别不同的功

Python多继承之MRO算法

MRO即Method Resolution Order   方法解析顺序,它的提出主要是为了解决Python中多继承时,当父类存在同名函数时,二义性的问题 下面先看一个例子: import inspect class D: pass class C(D): pass class B(D): pass class A(B, C): pass if __name__ == '__main__': print(inspect.getmro(A)) B和C继承D   A继承B和C  这是一个简单的多继承

python交互模式下的tab自动补全

python在交互模式下,输入命令的时候按tab键就按时间tab键的功能输出,在书写python时多有不便. 把下面的代码写入一个文件tab.py,放到/usr/lib/python2.6/site-packages/下 #!/usr/bin/env python import sys import readline import rlcompleter import atexit import os readline.parse_and_bind('tab:complete') histfil

Python 类继承,__bases__, __mro__, super

Python是面向对象的编程语言,也支持类继承. >>> class Base: ... pass ... >>> class Derived(Base): ... pass 这样就定义了两个类,Derived继承了Base.issubclass(a,b)能够測试继承关系: >>> issubclass(Derived, Base) True 在Python中,每一个类有一个__bases__属性,列出其基类 >>> Derived.