web-dev-qa-db-ja.com

新しいスタイルのクラスのメソッド解決順序（MRO）？

本Python in a Nutshell（2nd Edition）に使用する例があります
古いスタイルのクラスは、古典的な解決順序でメソッドが解決される方法を示し、
新しい注文との違いは何ですか。

サンプルを新しいスタイルで書き直して同じ例を試しましたが、結果は古いスタイルクラスで得られたものと変わりません。 python私が例を実行するのに使用しているバージョンは2.5.2。以下は例です：

_class Base1(object):  
    def amethod(self): print "Base1"  

class Base2(Base1):  
    pass

class Base3(object):  
    def amethod(self): print "Base3"

class Derived(Base2,Base3):  
    pass

instance = Derived()  
instance.amethod()  
print Derived.__mro__  
_

呼び出しinstance.amethod()は_Base1_を出力しますが、クラスの新しいスタイルでのMROの私の理解によれば、出力は_Base3_。呼び出し_Derived.__mro___は次を出力します。

_(<class '__main__.Derived'>, <class '__main__.Base2'>, <class '__main__.Base1'>, <class '__main__.Base3'>, <type 'object'>)_

新しいスタイルクラスでのMROの理解が間違っているのか、または検出できないばかげた間違いをしているのかはわかりません。 MROの理解を深めてください。

pythonmethod-resolution-order
85
sateesh

従来のクラスと新しいスタイルのクラスの解決順序の重要な違いは、同じ祖先クラスが「単純な」深さ優先アプローチで複数回発生する場合に発生します。たとえば、「ダイヤモンド継承」の場合を考えます。

>>> class A: x = 'a'
... 
>>> class B(A): pass
... 
>>> class C(A): x = 'c'
... 
>>> class D(B, C): pass
... 
>>> D.x
'a'

ここでは、レガシースタイルで、解像度の順序はD-B-A-C-Aです。したがって、D.xを検索するとき、Aはそれを解決するための解像度順序の最初のベースであり、それによってCの定義を隠します。

>>> class A(object): x = 'a'
... 
>>> class B(A): pass
... 
>>> class C(A): x = 'c'
... 
>>> class D(B, C): pass
... 
>>> D.x
'c'
>>>

ここで、新しいスタイルの順序は次のとおりです。

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

Aが1回だけ、すべてのサブクラスの後に解決順序に来るように強制されているため、オーバーライド（つまり、メンバーxのCのオーバーライド）は実際には賢明に動作します。

これは、古いスタイルのクラスを避ける必要がある理由の1つです。「ダイヤモンドのような」パターンによる多重継承は、新しいスタイルではできますが、それらでは賢明には機能しません。

168
Alex Martelli

Pythonのメソッド解決の順序は、ダイヤモンドパターンを理解するよりも実際には複雑です。 実際に理解するには、 C3線形化 を見てください。メソッドを拡張して順序を追跡するときにprintステートメントを使用すると本当に役立つことがわかりました。たとえば、このパターンの出力はどうなると思いますか？ （注：「X」はノードではなく2つの交差するエッジであると仮定し、^はsuper（）を呼び出すメソッドを示します）

class G():
    def m(self):
        print("G")

class F(G):
    def m(self):
        print("F")
        super().m()

class E(G):
    def m(self):
        print("E")
        super().m()

class D(G):
    def m(self):
        print("D")
        super().m()

class C(E):
    def m(self):
        print("C")
        super().m()

class B(D, E, F):
    def m(self):
        print("B")
        super().m()

class A(B, C):
    def m(self):
        print("A")
        super().m()


#      A^
#     / \
#    B^  C^
#   /| X
# D^ E^ F^
#  \ | /
#    G

A B D C E F Gを得ましたか？

x = A()
x.m()

多くの試行錯誤の後、次のようにC3線形化の非公式のグラフ理論の解釈を思い付きました（これが間違っているかどうかを教えてください）。

この例を考えてみましょう：

class I(G):
    def m(self):
        print("I")
        super().m()

class H():
    def m(self):
        print("H")

class G(H):
    def m(self):
        print("G")
        super().m()

class F(H):
    def m(self):
        print("F")
        super().m()

class E(H):
    def m(self):
        print("E")
        super().m()

class D(F):
    def m(self):
        print("D")
        super().m()

class C(E, F, G):
    def m(self):
        print("C")
        super().m()

class B():
    def m(self):
        print("B")
        super().m()

class A(B, C, D):
    def m(self):
        print("A")
        super().m()

# Algorithm:

# 1. Build an inheritance graph such that the children point at the parents (you'll have to imagine the arrows are there) and
#    keeping the correct left to right order. (I've marked methods that call super with ^)

#          A^
#       /  |  \
#     /    |    \
#   B^     C^    D^  I^
#        / | \  /   /
#       /  |  X    /   
#      /   |/  \  /     
#    E^    F^   G^
#     \    |    /
#       \  |  / 
#          H
# (In this example, A is a child of B, so imagine an Edge going FROM A TO B)

# 2. Remove all classes that aren't eventually inherited by A

#          A^
#       /  |  \
#     /    |    \
#   B^     C^    D^
#        / | \  /  
#       /  |  X    
#      /   |/  \ 
#    E^    F^   G^
#     \    |    /
#       \  |  / 
#          H

# 3. For each level of the graph from bottom to top
#       For each node in the level from right to left
#           Remove all of the edges coming into the node except for the right-most one
#           Remove all of the edges going out of the node except for the left-most one

# Level {H}
#
#          A^
#       /  |  \
#     /    |    \
#   B^     C^    D^
#        / | \  /  
#       /  |  X    
#      /   |/  \ 
#    E^    F^   G^
#               |
#               |
#               H

# Level {G F E}
#
#         A^
#       / |  \
#     /   |    \
#   B^    C^   D^
#         | \ /  
#         |  X    
#         | | \
#         E^F^ G^
#              |
#              |
#              H

# Level {D C B}
#
#      A^
#     /| \
#    / |  \
#   B^ C^ D^
#      |  |  
#      |  |    
#      |  |  
#      E^ F^ G^
#            |
#            |
#            H

# Level {A}
#
#   A^
#   |
#   |
#   B^  C^  D^
#       |   |
#       |   |
#       |   |
#       E^  F^  G^
#               |
#               |
#               H

# The resolution order can now be determined by reading from top to bottom, left to right.  A B C E D F G H

x = A()
x.m()
21
Ben

あなたが得る結果は正しいです。 Base3の基本クラスをBase1に変更して、クラシッククラスの同じ階層と比較してみてください。

class Base1(object):
    def amethod(self): print "Base1"

class Base2(Base1):
    pass

class Base3(Base1):
    def amethod(self): print "Base3"

class Derived(Base2,Base3):
    pass

instance = Derived()
instance.amethod()


class Base1:
    def amethod(self): print "Base1"

class Base2(Base1):
    pass

class Base3(Base1):
    def amethod(self): print "Base3"

class Derived(Base2,Base3):
    pass

instance = Derived()
instance.amethod()

今、それは出力します：

Base3
Base1

詳細については、 この説明 をお読みください。

5
Denis Otkidach

メソッドの解決は幅優先ではなく深さ優先であるため、この動作が見られます。 Derviedの継承は次のようになります

_         Base2 -> Base1
        /
Derived - Base3
_

instance.amethod()

  1. Base2をチェックし、メソッドが見つかりません。
  2. Base2がBase1から継承していることを確認し、Base1をチェックします。 Base1にはamethodがあるため、呼び出されます。

これは_Derived.__mro___に反映されます。 _Derived.__mro___を繰り返し処理し、探しているメソッドが見つかったら停止します。

0
jamessan