12 Python MRO

最新推荐文章于 2024-07-31 16:26:26 发布
最新推荐文章于 2024-07-31 16:26:26 发布
阅读量3.9k 收藏 28
点赞数 8
分类专栏： Python27 关注Python细节,第三方包学习 文章标签： Python-mro 方法解析顺序 MRO-C3 新式类 mro的计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lis_12/article/details/52859376
版权

Python MRO(方法解析顺序)

转载请标明出处(http://blog.csdn.net/lis_12/article/details/52859376).

MRO (Method Resolution Order)

Python在多重继承时,如果父类中存在同名函数会产生二义性,Python中处理这个问题方法就是MRO.

如果对MRO发展史没兴趣的话,直接看C3算法.

经典类,MRO=深度优先搜索

经典类是一种不能继承的类,如果经典类被作为父类,子类调用父类的构造函数则会出错.

经典类的MRO采用 “深度优先搜索“,子节点顺序从左到右;

经典类没有__mro__属性;

当出现菱形继承时,深度优先搜索就会出现问题.下面给出了正常继承模式和菱形继承模式下,采用DFS得出的MRO:

<画继承关系图时,要注意继承顺序,先继承的在最左侧,谨记这点,继承顺序不同,mro也是不一样的>

dfs

  1. 正常继承:

    如果两个互不相关的类多重继承,此时MRO正常,不会引起任何问题;

  2. 菱形继承:

    B和C有公共父类D,假设C重写了D中的fun()方法,按照MRO顺序先找到D中的fun()方法,此时C中重写的fun()方法将永远访问不到,导致了C只能继承不能重写D中的方法(即使C重写了fun()方法也不会访问到),这就是深度优先搜索的缺陷;

新式类,MRO = C3

为了使类和内置类型更加统一,解决经典类中多重继承只能继承不能重写的问题,引入了新式类.新式类的每个类都继承于一个基类(object),可以是自定义类或其他类,默认继承于object.子类可以调用父类的构造函数.

#经典类
class A():
    pass
#新式类
class A(object):
    pass

新式类采用C3算法求解mro,并且新式类是有__mro__属性的.

BFS,广度优先搜索

在介绍C3算法时,有必要了解BFS.如果新式类的MRO采用BFS(广度优先搜索,子节点顺序从左到右)

当出现正常继承时,广度优先搜索就会出现问题.下面给出了正常继承模式和菱形继承模式下,采用BFS得出的MRO:

<画继承关系图时,要注意继承顺序,先继承的在最左侧,谨记这点,继承顺序不同,mro也是不一样的>

bfs

  1. 正常继承:

    如果两个互不相关的类多重继承,则会发生问题.

    假设:D中有foo()方法,C也有foo()方法,则按照MRO顺序,应该是先在B中查找,再在C中查找.

    正常情况下,如果在B中未找到的话,应该在B的父类中查找,而不是在C中查找.

    这种先在B中查找然后再D中查找的顺序,称为单调性.(这就像继承遗产一样,如果继承人的儿子媳妇不在了,要先找继承人的孙子,孙女啊,而不是找什么侄子,外甥什么的…..)

  2. 菱形继承:

    解决了深度优先搜索出现的只能继承不能重写问题,但是违反了继承的单调性原则.

C3算法

下面开始正题,从Python2.3开始,新式类的MRO采用C3算法,解决了单调性和只能继承无法重写的问题.

MRO采用C3算法后,此时上述两种继承模式的MRO:

C3

代码实现:

#!/usr/bin/python
# -*- coding: utf-8 -*-
#正常继承.py
class D(object):
    def __init__(self):
        super(D,self).__init__()
        print 'D'

    def fun(self):
        print 'D fun()'

class E(object):
    def __init__(self):
        super(E,self).__init__()
        print 'E'

class C(E):
    def __init__(self):
        super(C,self).__init__()
        print 'C'
    def fun(self):
        print 'C fun()'

class B(D):
    def __init__(self):
        super(B,self).__init__()
        print 'B'

class A(B,C):
    def __init__(self):
        super(A,self).__init__()
        print 'A'

if __name__ == '__main__':#主程序
    a = A()  #E C D B A
    print A.__mro__#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <type 'object'>)  正确
    a.fun()  #D fun() 按照MRO搜索fun()方法,在D中找到

#菱形继承.py
#!/usr/bin/python
# -*- coding: utf-8 -*-

class D(object):
    def __init__(self):
        super(D,self).__init__()
        print 'D'

    def fun(self):
        print 'D fun()'

class C(D):
    def __init__(self):
        super(C,self).__init__()
        print 'C'

    def fun(self):
        print 'C fun()'

class B(D):
    def __init__(self):
        super(B,self).__init__()
        print 'B'

class A(B,C):
    def __init__(self):
        super(A,self).__init__()
        print 'A'

if __name__ == '__main__':#主程序
    a = A()  #DCBA
    print A.__mro__ #(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <type 'object'>)   正确
    a.fun()  #C fun()  按照MRO搜索fun()方法,在C中找到

C3算法成功解决了单调性和只能继承无法重写的问题.下面来看下神奇的C3算法是如何计算mro的.

C3算法计算访问顺序列表

merge list公式法

C3算法的核心就是merge.

在merge列表中，如果第一个序列mro的第一个类出现在其它序列，并且也是第一个，或者某个类仅在一个序列中存在,其它序列不存在，那么这个类就会从这些序列中删除，并合到访问顺序列表中,如果在第一个序列中未找到满足上述条件的类,则在第二个序列开始查找,如果在第二个中也找不到符合条件的,则在第三个序列中查找……

谨记:mro(object) = [O]

如:class B(A1,A2,A3 …) 继承顺序也很重要,不要忽略了

此时B的mro序列 mro(B) = [B] + merge(mro(A1), mro(A2), mro(A3) …, [A1,A2,A3])

merge中的排列要严格遵守继承顺序.

以正常继承模式的几个类为例:(O为object类,新式类为object的子类)

正常继承

mro(D) = [D,O]

mro(E) = [E,O]

mro(B) = [B] + merge(mro(D) ,[D]) = [B] + merge([D,O] + [D]) = [B,D] +merge([O]) = [B,D,O]

同理:mro(C) = [C,E,O]

mro(A) = [A] + merge(mro(B),mro(C),[B,C])

​ = [A] + merge([B,D,O],[C,E,O],[B,C]) #B为第一个序列的第一个类,并且B在第三个序列中也是第一个类,合并

​ = [A,B] + merge([D,O],[C,E,O],[C]) #D仅在第一个序列中存在,合并

​ = [A,B,D] + merge([O],[C,E,O],[C]) #第一个序列中O不满足任何条件,在第二个序列中查找,C为第二个序

​ 的第一个类,并且也为第三个序列的第一个类,合并

​ = [A,B,D,C] + merge([O],[E,O]) #第一个序列中的O不满足任何条件,在第二个序列中查找,E仅在第二

​ 个序列中存在,合并

​ = [A,B,D,C,E] + merge([O],[O]) #O为第一个序列的第一个类,也是第二个序列的第一个类,合并

​ = [A,B,D,C,E,O]
result: [A,B,D,C,E,O] 正确

拓扑排序求解mro

解决单调性(BFS正常继承出现的问题):只要保证从根到叶,从左到右的访问顺序即可;

只能继承,不能重写(DFS菱形继承出现的问题):主要是因为先访问了子类的父类导致的.

如果熟悉图论的话,应该能想到拓扑排序能很好的解决上述问题.

拓扑排序:

对于一个有向无环图G进行拓扑排序,就是将G中所有的顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)属于E(G),则u在线性序列中出现在v之前.通常,这样的线性序列称之为满足拓扑次序的序列,简称拓扑排序.

因为拓扑排序肯定是由根节点到叶节点,所以只要满足从左到右的原则,得到的拓扑排序就是mro.

以正常继承模式和菱形继承模式的几个类为例,用拓扑排序求解mro:

正常继承

  1. 找到入度为0的点,只有A,将A加入mro顺序列表中,剪掉与A相连的边;
  2. 再找入度为0的点,有两个点B和C,取最左,so将B加入mro顺序列表中,剪掉与B相连的边;
  3. 再找入度为0的点,有两个点D和C,取最左,so将D加入mro顺序列表中,剪掉与D相连的边;
  4. 再找入度为0的点,只有C,so将C加入mro顺序列表中,剪掉与C相连的边;
  5. 再找入度为0的点,只有E,so将E加入mro顺序列表中;

result: mro = [A,B,D,C,E] 正确

菱形继承:

这里写图片描述

  1. 找到入度为0的点,只有A,将A加入mro顺序列表中,剪掉与A相连的边;
  2. 再找入度为0的点,有两个点B和C,取最左,so将B加入mro顺序列表中,剪掉与B相连的边;
  3. 再找入度为0的点,只有C,so将C加入mro顺序列表中,剪掉与C相连的边;
  4. 再找入度为0的点,只有D,so将D加入mro顺序列表中;

result: mro = [A,B,C,D] 正确

比较BFS,DFS,C3求解mro

菱形继承

算法正常继承 mro顺序菱形继承 mro顺序
DFSA,B,D,C,EA,B,D,C (只能继承,不能重写问题)
BFSA,B,C,D,E(不满足单调性原则)A,B,C,D
C3A,B,D,C,EA,B,C,D

实战计算mro

#!/usr/bin/python
# -*- coding: utf-8 -*-
class E(object):
    pass

class D(object):
    pass

class F(object):
    pass

class C(D,F):
    pass

class B(E,D):
    pass

class A(B,C):
    pass

if __name__ == '__main__':
    print A.__mro__#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.F'>, <type 'object'>)

上述代码的继承关系图,继承顺序为从左到右:

继承关系图

利用merge计算A的mro:(O代表object类)

mro(E) = [E,O]

mro(D) = [D,O]

mro(F) = [F,O]

mro(B) = [B] + merge(mro(E),mro(D),[E,D])

​ = [B] + merge([E,O],[D,O],[E,D]) E符合merge条件

​ = [B,E] + merge([O],[D,O],[D]) D符合merge条件

​ = [B,E,D] + merge([O],[O],[]) O符合merge条件

​ = [B,E,D,O]

mro(C) = [C] + merge(mro(D),mro(F),[D,F])

​ = [C] + merge([D,O],[F,O],[D,F]) D符合merge条件

​ = [C,D] + merge([O],[F,O],[F]) F符合merge条件

​ = [C,D,F] + merge([O],[O],[]) O符合merge条件

​ = [C,D,F,O]

mro(A) = [A] + merge(mro(B),mro(C),[B,C])

​ = [A] + merge([B,E,D,O] ,[C,D,F,O] ,[B,C]) B符合merge条件

​ = [A,B] + merge([E,D,O] ,[C,D,F,O] ,[C]) E符合merge条件

​ = [A,B,E] + merge([D,O] ,[C,D,F,O] ,[C]) C符合merge条件

​ = [A,B,E,C] + merge([D,O] ,[D,F,O] ,[]) D符合merge条件

​ = [A,B,E,C,D] + merge([O] ,[F,O] ,[]) F符合merge条件

​ = [A,B,E,C,D,F] + merge([O] ,[O] ,[]) O符合merge条件

​ = [A,B,E,C,D,F,O] 与程序结果一致

利用拓扑排序计算mro

根据继承关系图,(简单来说就是不停找入度为0的点,然后减去相连的边,不停重复,直至只剩下一个点)

  1. 找到入度为0的点,只有A,将A加入mro顺序列表中,剪掉与A相连的边;
  2. 再找入度为0的点,有两个点B和C,取最左,so将B加入mro顺序列表中,剪掉与B相连的边;
  3. 再找入度为0的点,有两个点E和C,取最左,so将E加入mro顺序列表中,剪掉与E相连的边;
  4. 再找入度为0的点,只有C,so将C加入mro顺序列表中,剪掉与C相连的边;
  5. 再找入度为0的点,有两个点D和F,取最左,so将D加入mro顺序列表中,剪掉与D相连的边;
  6. 再找入度为0的点,只有F,so将F加入mro顺序列表中,剪掉与F相连的边;
  7. 只剩下object,将object加入mro顺序列表中;

此时得出mro = [A,B,E,C,D,F,O],与程序结果一致.

总结

mro的计算不必深究,了解就好,在实际应用时,直接使用class.__mro__查看方法解析顺序即可.另外在开发中要尽量避免多重继承,不要混用经典类和新式类……

参考网址

  1. (http://xymlife.com/2016/05/22/python_mro/)
  2. (https://segmentfault.com/a/1190000000749061)
  3. (http://www.cnblogs.com/lovemo1314/archive/2011/05/03/2035005.html)
  4. (http://www.cnblogs.com/i2u9/archive/2013/03/19/pythonmroc3.html)​
忧桑的小兔子
关注
专栏目录
Python多继承机制与MRO深度解析
windowshht的博客
04-23 730
在Python的面向对象编程中，多继承是一个强大的特性，它允许一个类继承自多个父类，从而集成多个父类的属性和方法。然而，多继承也带来了一个复杂的问题：当子类调用一个方法时，如果多个父类中都存在这个方法，Python应该如何决定调用哪个父类的方法？MRO是一个静态确定的顺序，它在类定义时就已经确定，并且在类的生命周期中保持不变。在复杂的类继承关系中，正确的MRO可以确保我们期望的方法被正确调用，避免潜在的问题和混淆。在实际编程中，如果遇到多继承相关的问题，我们可以通过查看类的MRO来调试和解决问题。
Python多继承以及MRO顺序的使用
09-18
在Python 2.3版本引入了`__mro__`属性，它是一个元组，按照MRO顺序存储了类的层次结构。当我们通过`super()`函数调用方法时，Python会按照MRO顺序查找并执行方法。 以下是一些关于Python多继承和MRO顺序的关键点： ...
python：MRO的计算方式
12-22
我们都已经知道，Python 3(Python 2 的新式类)中多继承模式是使用 C3 算法来确定 MRO(Method Resolution Order) 的。 下面就讲解C3算法具体是怎么计算的。 MRO计算规则 首先来定义一些符号: 用CN表示一个类：C1, C2, C3, ..., CN C1 C2 C3 ... CN 表示的是一个包含多个类的列表 其中： head = C1 tail = C2 ... CN 加法运算： C + (C1 C2 ... CN) = C C1 C2 ... CN L[C]表示类C的线性化，其实就是C的MRO，比如有个类： class C(B1
Python的MRO
热门推荐
鄙人张钊_有何贵干的博客
05-24 1万+
Python的MRO即Method Resolution Order（方法解析顺序），也就是在Python中的类的继承顺序是怎样的。在Python2.3之前，MRO的实现是基于DFS的，而在Python2.3以后MRO的实现是基于C3算法（我这里两种算法的具体实现都不详述）。C3算法最早被提出是用于Lisp的，应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级，和单调性的问题。...
python-----------MRO知识点笔记
最新发布
zy_666_king的博客
07-31 164
之所第一个图片打印的是A，第二张打印的是B，是因为在M这个类的mro中，在第一张图片中的程序中，M类的mro排序是类A在类B前面。所以在寻找say（）这个方法时，现在类M中找，再在类C张找，没有找A中找，当从类A中找到了say（）这个方法，直接调用l类C中的方法，不再向下寻找。在第二张图片中，M类的mro排序是类B在类A前面，按照M C B A的顺序，在M，C，B,A类中寻找say（）这个方法，因为B在A前，所以打印的结果时B。获得类的继承的优先级顺序，可以通过__mro__或者mro()d的方式。
Python之MRO
wguo-up-site
11-19 1378
1. MRO(Method Resolution Order) MRO即Method Resolution Order（方法解析顺序），即在调用方法时，会对当前类以及所有的基类进行一个搜索， 以确定该方法之所在，而这个搜索的顺序就是MRO。 一个类的 MRO 列表就是合并所有父类的 MRO 列表，并遵循以下三条原则： 1. 子类永远在父类前面 2. 如果有多个父类，会根据它们在列表中的顺序被检查 3. 如果对下一个类存在两个合法的选择，选择第一个父类 遇到多继承则按代码中继承列表的顺序从左往右写。若有类
python中的MRO
zhangdell的专栏
12-20 7284
一：什么是MRO 所谓的MRO，就是方法解析顺序(Method Resolution Order)。在调用方法时，会对当前类以及所有的基类进行一个搜索，确定要调用的方法具体在哪。不管用哪种方式去确定MRO列表，必须满足 本地优先级和单调性。 本地优先级：指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时，应该根据声明顺序，优先查找A类，然后再查找B类 单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里，也必须满足这个顺序 二：常见的mro算法 1：mro=深度优先遍历的(
Python MRO（方法解析顺序）
迹忆客
10-16 410
多重继承意味着单个子类可以继承多个类，并且子类将被授权访问属性和函数，除非它们不是该特定类的私有属性和函数。MRO 技术用于搜索正在执行的类的顺序。在这篇文章中，我们将学习Python MRO（方法解析顺序）。
浅谈Python的方法解析顺序(MRO)
09-17
Python的方法解析顺序（Method Resolution Order，MRO）是面向对象编程中一个关键的概念，尤其是在处理多继承时。MRO决定了当一个实例调用一个方法时，Python如何确定应该使用哪个父类的方法。MRO遵循一定的规则，...
python mro
09-12
Python中的MRO算法采用C3线性化算法来确定方法解析顺序。 在Python中，可以通过以下方式来查看类的方法解析顺序： 1. 使用`__mro__`属性：在类中使用`ClassName.__mro__`，可以查看该类的方法解析顺序。 示例...
python MRO()
人生苦短，何妨一试
11-25 662
Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右” 按顺序搜索 MRO （Method Resolution Order） ： 方法解析顺序。我们可以通过mro() 方法获得 “类的层次结构” ， 方法解析顺序也是按照这个 “类的层次结构” 寻找 class A: def test_a(self): print('A类') def MM(self): print('MM_A') class...
mro python_Python的mro
weixin_30512965的博客
02-07 201
一个python的super和mro问题今天让我纠结了一早上，源自于看tornado的源代码对于super这个“方法”产生的困惑，对于老鸟mro应该是常识了，对于小白而言，尼玛搞懂这个掉了我好几根头发。谷歌了一下找到一篇博客也在讨论这个问题，博主列举了一个例子我觉得很典型，同时他也提出了和我一样的问题，我在原文的引用中高亮了。下面摘自“JohnsonGuo的专栏”：有一天某同事设计了一个相对复杂的...
python中的mro
qugang1982的专栏
01-13 619
发现一个号网站：http://stackoverflow.com 现在才发现，土呀： 什么是MRO Follow along...: >>> class A(object): pass ... >>> A.__mro__ (, ) >>> class B(A): pass ... >>> B.__mro__ (, , ) >>> class C(A): pass ... >>
mro python_Python-MRO
weixin_39672396的博客
12-11 91
前言MRO(Method Resolution Order)：方法解析顺序。Python语言包含了很多优秀的特性，其中多重继承就是其中之一，但是多重继承会引发很多问题，比如二义性，Python中一切皆引用，这使得他不会像C++一样使用虚基类处理基类对象重复的问题，但是如果父类存在同名函数的时候还是会产生二义性，Python中处理这种问题的方法就是MRO。历史中的MRO如果不想了解历史，只想知道现在...
Python MRO
从菜鸟到菜菜鸟
10-10 2906
The Python 2.3 Method Resolution Order Version: 1.4 Author: Michele Simionato E-mail: michelesimionato@libero.it
【转】你真的理解Python中MRO算法吗？
weixin_34279246的博客
10-21 591
你真的理解Python中MRO算法吗？ MRO（Method Resolution Order）：方法解析顺序。 Python语言包含了很多优秀的特性，其中多重继承就是其中之一，但是多重继承会引发很多问题，比如二义性，Python中一切皆引用，这使得他不会像C++一样使用虚基类处理基类对象重复的问题，但是如果父类存在同名函数的时候还是会产生二义性，Python中处理这种问题的方法就是M...
python中的MRO与多继承
Han的小站
02-22 9386
相关概念： MRO：Method Resolution Order，即方法解析顺序，是python中用于处理二义性问题的算法   二义性： python支持多继承，多继承的语言往往会遇到以下两类二义性的问题： 有两个基类A和B，A和B都定义了方法f()，C继承A和B，那么调用C的f()方法时会出现不确定。 有一个基类A，定义了方法f(
python mro文件_Python面向对象之MRO
weixin_39769675的博客
12-11 160
Python是支持面向对象编程的，同时也是支持多重继承的。而支持多重继承，正是Python的方法解析顺序(Method Resoluthion Order, 或MRO)问题出现的原因所在。python中至少有三种不同的MRO:经典类(calssic class)，深度优先遍历在python2.2中提出了type和class的统一，出现了一个内建类型以及自定义类的公共祖先object，即新式类(ne...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值