Python 什么是；mro（）；做

在

django.utils.functional.py

中：

for t in type(res).mro():  # <----- this
    if t in self.__dispatch:
        return self.__dispatch[t][funcname](res, *args, **kw)

表示类型（res.mro（）：#
mro（）
表示方法解析顺序。它返回类派生自的类型的列表，按照它们在方法中的搜索顺序

mro（）或仅在新样式类上工作。在Python3中，它们可以正常工作。但是在Python2中，这些类需要从
对象继承
下面是…：

>>> class A(object): pass
... 
>>> A.__mro__
(<class '__main__.A'>, <type 'object'>)
>>> class B(A): pass
... 
>>> B.__mro__
(<class '__main__.B'>, <class '__main__.A'>, <type 'object'>)
>>> class C(A): pass
... 
>>> C.__mro__
(<class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
>>> 

…您还可以得到保证，在
\uuuuMRO\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

在类实例上获得的每个属性，而不仅仅是方法，在概念上都是沿着
\uuuumro\uuuuu
查找的，因此，如果祖先中有多个类定义了该名称，这将告诉您在哪里可以找到该属性——在定义该名称的
\uuu mro\uuu
中的第一个类中。
这可能会显示解析顺序

class A(object):
    def dothis(self):
        print('I am from A class')

class B(A):
    pass

class C(object):
    def dothis(self):
        print('I am from C class')

class D(B, C):
    pass

d_instance= D()
d_instance.dothis()
print(D.mro())

对此的反应是

I am from A class
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class 'object'>]

我来自一个班级
[, , ]

规则是深度优先，在这种情况下意味着D，B，A，C

Python在搜索继承类时通常使用深度优先的顺序，但是当两个类从同一个类继承时，Python会从mro中删除该类的第一次提及。
菱形继承中的解析顺序会有所不同

class A(object):
    def dothis(self):
        print('I am from A class')


class B1(A):
    def dothis(self):
        print('I am from B1 class')
    # pass


class B2(object):
    def dothis(self):
        print('I am from B2 class')
    # pass


class B3(A):
    def dothis(self):
        print('I am from B3 class')


# Diamond inheritance
class D1(B1, B3):
    pass


class D2(B1, B2):
    pass


d1_instance = D1()
d1_instance.dothis()
# I am from B1 class
print(D1.__mro__)
# (<class '__main__.D1'>, <class '__main__.B1'>, <class '__main__.B3'>, <class '__main__.A'>, <class 'object'>)


d2_instance = D2()
d2_instance.dothis()
# I am from B1 class
print(D2.__mro__)
# (<class '__main__.D2'>, <class '__main__.B1'>, <class '__main__.A'>, <class '__main__.B2'>, <class 'object'>)

A类（对象）：
def dothis（自我）：
打印（'我来自一个班级'）
B1（A）类：
def dothis（自我）：
打印（'我来自B1班'）
#通过
B2类（对象）：
def dothis（自我）：
打印（'我来自B2类'）
#通过
B3（A）类：
def dothis（自我）：
打印（'我来自B3类'）
#钻石遗产
D1类（B1、B3）：
通过
D2类（B1、B2）：
通过
d1_实例=d1（）
d1_实例.dothis（）
#我是B1班的
打印（D1.\uuuuMRO\uuuuuuuuuuuu）
# (, , )
d2_实例=d2（）
d2_实例。dothis（）
#我是B1班的
打印（D2.\uuuuMRO\uuuuuuuuuuu）
# (, , )
嗨，alex，D.uuuMRO_uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu，当使用新类时，应该添加mro属性，因为只有在使用Python2.2 mro和Python2.3 mro（C3）时才应该添加mro属性。因此，正如您所看到的，顺序是D、B、A、C，您所说的“Python从mro中删除了对该类的第一次提及”是什么意思？@Ruthvikvailla：我认为这部分表述得很糟糕。在这篇关于Python历史的文章中，Guido van Rossum评论道（关于Python 2.2中引入的MRO方案）“如果在这个搜索中有任何类被复制，除了最后一次出现之外，所有的类都将从MRO列表中删除”（我的重点）。这意味着它可以删除的不仅仅是类的第一个“提及”。但是为什么解析不同呢？在多重继承场景中，在当前类中首先搜索任何指定的属性。如果找不到，搜索将继续深入到父类，先左后右，而不搜索同一类两次。对不起，我不明白为什么在第一种情况下它会转到
类B3
，但在第二种情况下它会转到
类A
后
类B1
class A(object):
    def dothis(self):
        print('I am from A class')


class B1(A):
    def dothis(self):
        print('I am from B1 class')
    # pass


class B2(object):
    def dothis(self):
        print('I am from B2 class')
    # pass


class B3(A):
    def dothis(self):
        print('I am from B3 class')


# Diamond inheritance
class D1(B1, B3):
    pass


class D2(B1, B2):
    pass


d1_instance = D1()
d1_instance.dothis()
# I am from B1 class
print(D1.__mro__)
# (<class '__main__.D1'>, <class '__main__.B1'>, <class '__main__.B3'>, <class '__main__.A'>, <class 'object'>)


d2_instance = D2()
d2_instance.dothis()
# I am from B1 class
print(D2.__mro__)
# (<class '__main__.D2'>, <class '__main__.B1'>, <class '__main__.A'>, <class '__main__.B2'>, <class 'object'>)