总之，因为 C
取决于E
你可以在依赖-图（O是见object
）：
Python的 方法解析顺序（MRO） 的约束条件是，如果类 a 是类 b 的依赖项，则将其放置在队列中比 b 靠后的位置。
现在更多的理论：
在Python中，MRO使用以下 线性化 规则：
L [
C(B1 ... Bn)] = C + merge（L [B1] … L [Bn]，B1…Bn） ; 和L [
object] =object
（资源）
而 合并 被定义为：
以第一个列表的开头，即L [
B1][0]；如果此头不在任何其他列表的尾部，则将其添加到C的线性化中，然后从合并中的列表中将其删除，否则，请查看下一个列表的头并采用它，如果它是一个好头
然后重复该 *** 作，直到所有班级都被删除，或者不可能找到好头子。在这种情况下，不可能构造合并，Python 2.3将拒绝创建类C并引发异常。
（资源）
因此，对于您的情况，第一步是：
L [A
] = A
+ merge（L [ D
]，L [ B
]，L [ E
]）
让我们首先解决递归调用：
L [D
] = D
+ merge（L [ E
]，L [ F
]） ;
L [B
] = B
+ merge（L [ C
]，L [ H
]） ; 和
L [E
] = E
+ merge（L [ G
]，L [ H
]）。
还有更多的递归（我们只做
H一次，不做重做
E）：
L [F
] = F
+ merge（L [ O
]） ;
L [C
] = C
+ merge（L [ E
]，L [ G
]） ;
L [G
] = G
+ merge（L [ O
]） ; 和
L [H
] = H
+ merge（L [ O
]）。
由于 L [O
]_是O
和 _合并的（a） （用于一个对象是 一个 ），我们由此已经获得用于序列
H，
G和
F：
L [H
] =（H
，O
）。
L [G
] =（G
，O
）。
L [F
] =（F
，O
）。
现在我们可以计算 L [E
]：
L [E
] = E
+ merge（（G
，O
），（H
，O
））。
由于
O两者都位于尾部，因此放在最后：
L [E
] =（ ，E
，G
，H
）O
。
现在我们可以计算 L [C
]：
L [C
] = C
+合并（（ ，E
，G
，H
），（O
，））G``O
;
L [C
] =（ C
，E
）+合并（（ ，G
，H
），（O
，））G``O
;
L [C
] =（ ，，C
）+合并（（ ，），（ ））E``G``H``O``O
;
L [C
] =（ ，C
，，E
）+合并（（ ），（））G``H``O``O
;
* L [
C] =（ ，
C，
E，
G，）。
H``O
和 L [D
]：
L [D
] = D
+合并（（ ，E
，G
，H
），（O
，））F``O
;
..;
L [D
] =（ ，D
，E
，G
，H
，F
）O
。
下一个 _L [
B]_可以完全解析：
L [B
] = B
+合并（（ ，C
，E
，G
，H
），（O
，））H``O
;
..;
L [B
] =（ ，B
，C
，E
，G
，H
）O
。
现在我们终于可以解决：
L [A
] = A
+合并（（ ，D
，E
，G
，H
，F
），（O
， ， ，B
，C
，），（E
， ，，
））G``H``O``E``G``H``O
;
L [A
] =（ A
，D
）+合并（（ ，E
，G
，H
，F
），（O
， ， ，B
，C
，），（E
， ，，
））G``H``O``E``G``H``O
;
L [A
] =（ ，，A
）+合并（（ ，，，，），（， ， ，，），（
，D``B``E``G``H``F``O``C``E``G``H``O``E``G
，H
，O
）） ;
L [A
] =（ ，A
，，D
）+合并（（ ，，，，），（， ， ，），（ ， ，，
））B``C``E``G``H``F``O``E``G``H``O``E``G``H``O
;
L [A
] =（ ，A
，D
，，B
）+合并（（ ，，，），（， ， ），（ ，
，））C``E``G``H``F``O``G``H``O``G``H``O
;
L [A
] =（ ，A
，D
，B
，，C
）+合并（（ ，，），（， ），（E``G``H``F``O``H``O``H
，O
））
;
L [A
] =（ ，A
，D
，B
，C
，，E
）+合并（（ ，），（），（ ））G``H``F``O``O``O
;
L [A
] =（ ，A
，D
，B
，C
，E
，，G
）+合并（（ ），（），（ ））H``F``O``O``O
;
L [A
] =（ ，A
，D
，B
，C
，E
，G
，H
，F
）O
。
这是预期的行为。
一个 效率不高， 我做了合并功能，可用于教育目的，这绝对不是为生产而优化：
def mro_merge(*args): for i,arg in enumerate(args): if len(arg) > 0: head = arg[0] for argb in args: if head in argb[1:]: break else: newargs = tuple(argb if len(argb) > 0 and argb[0] != head else argb[1:] for argb in args) print('mro_merge(%s) = %s + mro_merge(%s)'%(args,head,newargs)) yield head for x in mro_merge(*newargs): yield x break当您调用它时，它会生成：
>>> list(mro_merge(('G','O'),('H','O')))mro_merge((('G', 'O'), ('H', 'O'))) = G + mro_merge((('O',), ('H', 'O')))mro_merge((('O',), ('H', 'O'))) = H + mro_merge((('O',), ('O',)))mro_merge((('O',), ('O',))) = O + mro_merge(((), ()))['G', 'H', 'O']>>> list(mro_merge( ('D','E','G','H','F','O') , ('B','C','E','G','H','O') , ('E','G','H','O') ))mro_merge((('D', 'E', 'G', 'H', 'F', 'O'), ('B', 'C', 'E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O'))) = D + mro_merge((('E', 'G', 'H', 'F', 'O'), ('B', 'C', 'E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O')))mro_merge((('E', 'G', 'H', 'F', 'O'), ('B', 'C', 'E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O'))) = B + mro_merge((('E', 'G', 'H', 'F', 'O'), ('C', 'E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O')))mro_merge((('E', 'G', 'H', 'F', 'O'), ('C', 'E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O'))) = C + mro_merge((('E', 'G', 'H', 'F', 'O'), ('E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O')))mro_merge((('E', 'G', 'H', 'F', 'O'), ('E', 'G', 'H', 'O'), ('E', 'G', 'H', 'O'))) = E + mro_merge((('G', 'H', 'F', 'O'), ('G', 'H', 'O'), ('G', 'H', 'O')))mro_merge((('G', 'H', 'F', 'O'), ('G', 'H', 'O'), ('G', 'H', 'O'))) = G + mro_merge((('H', 'F', 'O'), ('H', 'O'), ('H', 'O')))mro_merge((('H', 'F', 'O'), ('H', 'O'), ('H', 'O'))) = H + mro_merge((('F', 'O'), ('O',), ('O',)))mro_merge((('F', 'O'), ('O',), ('O',))) = F + mro_merge((('O',), ('O',), ('O',)))mro_merge((('O',), ('O',), ('O',))) = O + mro_merge(((), (), ()))['D', 'B', 'C', 'E', 'G', 'H', 'F', 'O']欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）