Pythonでのメソッド解決順序

このノートでは、MRO C3アルゴリズムと、多重継承の特定の問題について説明します。 アルゴリズムと問題は1つの言語のフレームワークに限定されませんが、私はPythonに焦点を当てました。 最後に、このトピックに関する役立つリンクのリストがあります。





メソッドの解決順序により、Pythonは子孫クラスで直接見つからない場合、どの祖先クラスからメソッドを呼び出すかを判断できます。 各子孫に祖先が1つしかない場合、タスクは簡単です。 階層全体で上方検索が行われます。 多重継承が使用されている場合、以下に説明する特定の問題が発生する可能性があります。



Pythonの古いバージョンでは、メソッド解決の順序は非常に原始的でした。検索は、すべての親クラスで左から右、最大の深さまで実行されました。 つまり 次に、親クラスに目的のメソッドがなく、親がある場合、同じルールに従って検索が実行されます。 たとえば、次の構造を取ります。

 AC
 |  |
 Bd
  \ /
    E

クラスEのインスタンスメソッドを参照する場合、このようなアルゴリズムはクラスE、B、A、D、およびCを順番に検索します。したがって、検索は最初に最初の親クラスとそのすべての祖先で実行され、次にすべての祖先を持つ2番目の親クラスで実行されましたなど。このメソッドは、クラスが共通の祖先を持つまで特定の苦情を引き起こしませんでした。 ただし、バージョン2.2以降では、基本クラスオブジェクトが表示されたため、すべてのユーザークラスを継承することをお勧めします。 なぜ導入されたかは、別の記事のトピックです。 おそらく最も重要な要因は、オブジェクトモデルとメタデータモデルの分離です。 バージョン3.0以降、古いクラスはサポートされなくなり、すべてのユーザークラスはデフォルトでオブジェクトクラスに由来します。



これにより、「ダイヤモンド図」問題が発生しました。

   対象
    / \
   Ab
    \ /
      C

クラスCが継承されるクラスAとBがある場合、古いアルゴリズム（C、A、オブジェクト、B）を使用してメソッドを検索すると、メソッドがクラスCとAで定義されていない場合、オブジェクトから抽出されますBで定義されている場合。これにより、特定の不便が生じます。 オブジェクトは、__ init __、__ str__などの多くのマジックメソッドを定義します。 しかし、オブジェクトを特定のユーザークラスDに置き換えても、問題は残ります-下位クラスのより具体的なメソッドの代わりに、先祖クラスのより具体性の低いメソッドが機能します。



したがって、クラス自体、そのすべての祖先のリスト、およびそれらの間の接続を手にしています。 このデータから、メソッドが左から右に検索されるクラスの順序付きリストを作成する必要があります。 このようなリストは、クラスの線形化と呼ばれます。 簡単にするために、次の構造を取ります。

対象
    | 
    A
    |
    B

クラスBの線形化はリスト[B、A、object]になります。 つまり B（）.something（）が呼び出されると、メソッドは最初にクラスBで検索されます。そこで見つからない場合、クラスAで検索が続行されます。見つからない場合、検索はクラスオブジェクトで終了します。 線形化からすべてのクラスを通過し、正しいメソッドが見つからなかった後、Pythonは属性エラーをスローします。



菱形構造の問題を解決するには、線形化は単調でなければなりません。 これは、特定のクラスCの線形化でクラスAがクラスBに続く場合（[C、...、B、...、A]の形式を持っている）、その子孫DクラスBが線形化でAに続くことを意味します（ [D、...、C、...、B、...、A]）のようになります）。 ご覧のとおり、メソッド解決の古い順序は単調ではありません。 クラスAのrhomboid構造の場合、線形化は[A、オブジェクト]、クラスB-[B、オブジェクト]ですが、クラスC-[C、A、オブジェクト、B]の場合、クラスBに関して単調性プロパティに違反します。



単調性の特性を満たすには、この場合、2つの線形化が適切です：[C、A、B、object]および[C、B、A、object]。 明らかに、両方ともクラスA（両方の場合にオブジェクトがAに続くため）またはクラスB（両方の場合にオブジェクトがBに続くため）に関して単調性に違反しません。 どちらを選択するのですか？ この場合、最も直感的な方法は、クラスCの定義を見ることです。クラスがC（A、B）として宣言されている場合、BがAに続くため、最初の線形化を行うのが賢明です。クラスがC（B、A ）、その後、AがBに続く2番目の線形化を行う方が良いでしょう。



この選択は、ローカルの優先順位によって決定されます。 ローカル優先順位のプロパティは、宣言時と同じ順序の子孫クラスの線形化における親クラスの遵守を必要とします。 たとえば、クラスがD（A、B、C）として宣言されている場合、Dの線形化では、クラスAはBの前に、クラスBはCの前になければなりません。



中間結果を要約するには：

• クラスの線形化は、クラス自体と、そのメソッドの左から右への順序で検索されるすべての祖先（親と祖先）のリストです。
• メソッド解決順序（MRO）は、クラスの線形化をコンパイルする方法です。
• 単調性は、親クラスの線形化と同じ順序の親クラスの子孫クラスの線形化を順守する必要があるプロパティです。
• ローカルの優先順位は、子クラスの線形化が宣言と同じ親クラスの順序に従うように要求するプロパティです。

私たちは、線形化が単調さと地元の年功序列の両方を尊重することを望んでいます。

C3メソッドの解決のための解決アルゴリズム。

上記の目標を達成するために、PythonはC3アルゴリズムを使用します。 これは非常に単純ですが、理解を深めるために、次の規則を導入します。

[C1、C2、... CN]-要素C1、C2、... CNのリスト。 したがって、[C]は1つの要素Cのリストです。

L [C]はクラスCの線形化です。線形化は定義によるリストであることを覚えておくことが重要です。

merge（L [C1]、L [C2]、...、L [CN]）-線形化要素L [C1]、L [C2]、...、L [CN]を何らかのアルゴリズムを使用してリストにマージします。 実際、このアルゴリズムはL [C1]、L [C2]、...、L [CN]からすべてのクラスを順序付け、最終リストのクラスの重複を除外する必要があります。



アルゴリズムC3は、次のルールのセットです。

• クラスC線形化は、クラスC自体からのシングルトンリストに、その親の線形化とそのすべての親のリストの和集合を加えたものです。 凡例では、クラスCが次の場合、L [C] = [C] + merge（L [C1]、L [C2]、...、L [CN]、[C1、C2、...、CN]）と書くことができます。クラスC（C1、C2、...、CN）として宣言されています。 L [CX]の各線形化はクラスCXで始まり、クラスCの直接の親としてユニオンリストの最後に追加で割り当てられていることに注意してください。
• 線形化の組み合わせは次のとおりです。
  
  
  1. 最初の線形化からゼロ要素が取得されます（L [C1] [0]）。
  2. この要素は、他のすべての線形化（L [C2]からL [CN]まで）で求められます。
  3. この要素がリストの先頭以外の場所で見つかった場合（L [CK] [X] == L [C1] [0]、X！= 0;本質的に、これはL [C1] [0]が他の誰かの先祖）、アルゴリズムは最初のステップに進み、次の線形化（L [C2] [0]）からゼロ要素として取得します。
  4. 要素がゼロ以外の位置で見つからない場合、線形化要約リストの最後に追加され、問題のすべてのリストから削除されます（L [C1]からL [CN]。最終クラスで同じクラスを2回見つけることはできません） 。 要素を削除した後に空のリストがある場合、それらは結合から除外されます。 その後、アルゴリズムは最初から（新しい要素L [C1] [0]から）繰り返されます（存在する場合）。 存在しない場合、結合は完了します。
  5. アルゴリズムがL [CN]の最後の要素に到達したが、ゼロ要素がルールを満たさない場合、線形化は不可能です。
  
  
  

アルゴリズムをより理解しやすくするために、いくつかの例を調べてみましょう。 まず、rhomboid構造で何が起こっているのかを見てみましょう。 彼女のために：

L [C] = [C] +マージ（L [A]、L [B]、[A、B]）

L [A] = [A] +マージ（L [オブジェクト]、[オブジェクト]）

L [B] = [B] +マージ（L [オブジェクト]、[オブジェクト]）

L [オブジェクト] = [オブジェクト]（縮退ケース）



統合のプロセスは最も興味深いので、より詳細に分析します。 L [A]およびL [B]の場合、式merge（L [object]、[object]）= merge（[object]、[object]）は簡単に展開します。 1番目と2番目のリストは両方とも1つのオブジェクト要素で構成されているため、ユニオンルールの条項4に従って、結果は[オブジェクト]になります。



L [C] = [C] + merge（L [A]、L [B]、[A、B]）= [C] + merge（[A、object]、[B、object]、[A 、B]）。 C3のルールに従って組合を書きます。

• 最初のリストのゼロ要素を取得します-A
• 他のすべてのリストでそれを探しましょう。 [B、object]および[A、B]で。
• クラスAはリスト[B、object]に見つからず、リスト[A、B]はゼロ要素であるため、最終線形化リストL = [] + [A] = [A]に追加します。 その後、ユニオンのすべてのリストからクラスAを削除する必要があります。 L [C] = [C] + [A] + merge（[オブジェクト]、[B、オブジェクト]、[B]）を取得します。
• 繰り返しますが、最初のリストのゼロ要素-オブジェクトを取得します。
• 他のすべてのリストを調べて、オブジェクトがリストの最初の（nullではない）要素であることを見つけましょう[B、object]。 上記のように、本質的に、これはクラスオブジェクトがクラスBの祖先であることを意味します。したがって、最初はクラスBでより具体的なメソッドを探すことが理にかなっています。したがって、アルゴリズムはステップ1にかなり戻ります。
• 再び、ゼロ要素を取りますが、今回は2番目のリスト、つまり リスト[B、オブジェクト]からのB。
• 他のリストでそれを探し、ゼロの位置にある3番目のリスト[B]でのみ見つけます。 したがって、最終リストに追加してから、ユニオン内のすべてのリストから削除します。 L = [A] + [B] = [A、B]になり、それに応じてL [C] = [C] + [A、B] + merge（[object]、[object]）が得られます。
• 結果として生じるマージユニオン（[オブジェクト]、[オブジェクト]）はすでに上で議論されています。 結果として、L [C] = [C] + [A、B] + [object] = [C] + [A、B、object] = [C、A、B、object]が得られます。 リスト[A、B、オブジェクト]は、マージアソシエーションの結果です（L [A]、L [B]、[A、B]）。

アルゴリズムがより明確になることを願っています。 ただし、ルールに従って関連付けの最後にすべての親のリストを追加する必要がある理由はまだ明らかではありません。 特に意外なのは、結合のL [A]とL [B]の線形化を変更すると、つまり、 マージ（L [B]、L [A]、[A、B]）を記述すると、子孫クラスクラスC（A、B）を初期化するときと同じ順序で指定された親のリストはクラスBを許可しませんAの前に検索されます。それは事実です。 地元の年功序列に違反しないように、両親のリストが必要です。 しかし、クラスC（D、E）の例を見てみましょう。

対象
   |
   D
   |  \
   |  E
   |  /
   C

線形化L [C]を書きます。

L [C] = [C] +マージ（L [D]、L [E]、[D、E]）

L [E] = [E] +マージ（L [D]、[D]）

L [D] = [D] +マージ（L [オブジェクト]、[オブジェクト]）= [D、オブジェクト]



置換を実行して取得します。

L [E] = [E] +マージ（[D、オブジェクト]、[D]）= [E、D、オブジェクト]

L [C] = [C] +マージ（[D、オブジェクト]、[E、D、オブジェクト]、[D、E]）



今、私たちが得たものを見てください。 リスト[D、object]および[D、E]ではゼロ要素がDであるため、マージマージ（[D、object]、[E、D、object]、[D、E]）は完了できません。リスト項目[E、D、オブジェクト]。 逆に、[E、D、object]のヌル要素であるEは、[D、E]の最初の要素でもあります。 したがって、3回の反復の後、アルゴリズムはステップ5に進み、その後PythonはTypeErrorエラーをスローします：ベースD、Eに対して一貫したメソッド解決順序（MRO）を作成できません。結合が親のリストで終了しなかった場合、順序違反が発生します。ローカルの年功序列：L [C] = [C] +マージ（[D、オブジェクト]、[E、D、オブジェクト]）= [C] + [E] +マージ（[D、オブジェクト]、[D、オブジェクト] ）= [C] + [E、D] + [object] = [C、E、D、object]。 クラスCのこのような線形化では、検索は最初にクラスEで実行され、次にクラスDで実行されますが、C（D、E）は宣言で記述されています。



この問題を解決することは難しくありません。 クラスC（E、D）の宣言を書き直すだけで十分です。 この場合、次のようになります。

L [C] = [C] +マージ（[E、D、オブジェクト]、[D、オブジェクト]、[E、D]）= [C] + [E] +マージ（[D、オブジェクト]、[D 、オブジェクト]、[D]）= [C] + [E、D、オブジェクト] = [C、E、D、オブジェクト]。

実際、クラス宣言では、親をリストする順序はクラスの線形化と同じである、つまり、 地元の年功序列が尊重されます。 Pythonは親を示すのがより論理的な順序であることを示唆していますが、メタクラスを介して独自のMROを宣言する場合、冒険を探すことを止めることはありません。 しかし、それについてはもうすぐ終わりです。



Pythonは、クラスの作成時に線形化を1回計算します。 自己テストやその他の目的で取得する場合は、__ mro__クラスプロパティ（たとえば、C .__ mro__）を使用します。 素材を統合するために、貧しい人々の例を見てみましょう。 オブジェクトクラスは、線形化を混乱させないように意図的にスローされます。 上記からわかるように、単一継承では、クラスは子孫から祖先に単純に並んでいるため、オブジェクトは常にチェーンの最後になります。 その他。 私は料理の専門家でも音楽家でもないので、例は単なる例です。 それらの意味の不正確さに焦点を合わせるべきではありません。

       ミュージック
       / \
   ロックゴシック------
    / \ / \
メタルゴシックロック\
   |  |  \
    \ ------------------ゴシックメタル
                 |  /
                 69目

class Music (object): pass

class Rock (Music): pass

class Gothic (Music): pass

class Metal (Rock): pass

class GothicRock (Rock, Gothic): pass

class GothicMetal (Metal, Gothic): pass

class The69Eyes (GothicRock, GothicMetal): pass







L [The69Eyes] = [The69Eyes] + merge（L [GothicRock]、L [GothicMetal]、[GothicRock、GothicMetal]）

L [GothicRock] = [GothicRock] + merge（L [ロック]、L [ゴシック]、[ロック、ゴシック]）

L [GothicMetal] = [GothicMetal] + merge（L [金属]、L [ゴシック]、[金属、ゴシック]）

L [ロック] = [ロック、音楽]

L [ゴシック] = [ゴシック、音楽]

L [金属] = [金属] + [ロック、音楽] = [金属、ロック、音楽]



置換後：

L [GothicRock] = [GothicRock] + merge（[ロック、音楽]、[ゴシック、音楽]、[ロック、ゴシック]）= [GothicRock、ロック、ゴシック、音楽]

L [GothicMetal] = [GothicMetal] + merge（[金属、ロック、音楽]、[ゴシック、音楽]、[金属、ゴシック]）= [GothicMetal] + [金属、ロック、ゴシック、音楽] = [GothicMetal、金属、ロック、ゴシック、音楽]

L [The69Eyes] = [The69Eyes] + merge（[GothicRock、Rock、Gothic、Music]、[GothicMetal、Metal、Rock、Gothic、Music]、[GothicRock、GothicMetal]）

= [The69Eyes] + [GothicRock、GothicMetal] + merge（[ロック、ゴシック、音楽]、[金属、ロック、ゴシック、音楽]）

= [The69Eyes] + [GothicRock、GothicMetal、Metal] + merge（[ロック、ゴシック、音楽]、[ロック、ゴシック、音楽]）

= [The69Eyes、GothicRock、GothicMetal、メタル、ロック、ゴシック、音楽]

      食べ物-------
      / \ \
    肉粉
     |  \ \ /  
ウサギ豚肉ペースト
       \ | |  /
         パイ

class Food (object): pass

class Meat (Food): pass

class Milk (Food): pass

class Flour (Food): pass

class Rabbit (Meat): pass

class Pork (Meat): pass

class Pasty (Milk, Flour): pass

class Pie (Rabbit, Pork, Pasty): pass







L [パイ] = [パイ] +マージ（L [ウサギ]、L [ポーク]、L [ペーストリー]、[ウサギ、ポーク、ペースト状]）

L [ウサギ] = [ウサギ] +マージ（L [肉]、[肉]）

L [豚肉] = [豚肉] +マージ（L [肉]、[肉]）

L [Pasty] = [Pasty] + merge（L [牛乳]、L [小麦粉]、[牛乳、小麦粉]）

L [肉] = [肉] +マージ（L [食品]、[食品]）= [肉、食品]

L [牛乳] = [牛乳] +マージ（L [食物]、[食物]）= [牛乳、食物]

L [小麦粉] = [小麦粉] +マージ（L [食品]、[食品]）= [小麦粉、食品]



置換後、次のようになります。

L [ウサギ] = [ウサギ、肉、食物]

L [豚肉] = [豚肉、肉、食べ物]

L [Pasty] = [Pasty] + merge（[牛乳、食品]、[小麦粉、食品]、[牛乳、小麦粉]）= [Pasty] + [牛乳、小麦粉、食品] = [Pasty、牛乳、小麦粉、食品]

L [パイ] = [パイ] +マージ（[ウサギ、肉、食品]、[豚肉、肉、食品]、[香味、ミルク、小麦粉、食品]、[ウサギ、豚肉、ペースト状]）

= [パイ] + [ウサギ] +マージ（[肉、食品]、[豚肉、肉、食品]、[ペースト、牛乳、小麦粉、食品]、[豚肉、ペースト状]）

= [パイ] + [ウサギ、豚肉] +マージ（[肉、食品]、[肉、食品]、[ペースト、ミルク、小麦粉、食品]、[ペースト]）

= [パイ] + [ウサギ、ポーク、肉] +マージ（[フード]、[フード]、[パスティ、ミルク、小麦粉、フード]、[パスティ]）

= [パイ] + [ウサギ、豚肉、肉、パスティ] +マージ（[食品]、[食品]、[牛乳、小麦粉、食品]）

= [パイ] + [ウサギ、豚肉、肉、ペースト、ミルク、小麦粉、食品]

= [パイ、ウサギ、豚肉、肉、ペースト、ミルク、小麦粉、食品]

先祖への連絡方法。

多重継承には別の特定の問題があります。 実際、親クラスのメソッドの直接検索は、親クラスから派生できる利点の一部にすぎません。 単一継承の場合のように、いくつかのアクションに加えて、同じ親メソッドを呼び出すメソッドを子孫に実装することにより、多くの場合、生活を楽にすることができます。 たとえば、かなり頻繁にこれを見つけることができます：

class B (A):

def __init__ (self):

# something

A. __init__ (self)







ただし、多重継承の場合、このアプローチは適していません。 そして、どのような理由で：

class C (B, A):

def __init__ (self):

# something

B. __init__ (self)

A. __init__ (self)







最初に、親クラスを明示的に参照します（実際、単一継承の場合も同様です）。 祖先の1つを別のクラスに置き換えるか、完全に削除する場合は、アクセスしたすべての関数を変更する必要があります。 何かを見逃すと、これにはバグがたくさんあります。 しかし、これはまだ問題の半分です。 第二に、クラスAとクラスBについては何も知りません。おそらく、それらは同じような方法で参照する共通の祖先を持っています。

class A (P1, P2):

def __init__ (self):

# something

P1. __init__ (self)

P2. __init__ (self)



class B (P1, P2):

def __init__ (self):

# something

P1. __init__ (self)

P2. __init__ (self)







その場合、共通の祖先の初期化が2回機能することがわかります。 これは正しくありません。 これを避けるために、Pythonにはスーパークラスがあります。 バージョン3.0では、彼は最終的に人間化され、次のようにアクセスできます。

class C (B, A):

def __init__ (self):

# something

super (). __init__ () # 3.0 super(C, self)







バージョン2.xでは、最初の引数は親ではなくクラス自体を指定する必要があることに注意してください。 実際、スーパークラスオブジェクトは、初期化時に渡された引数を記憶し、メソッド（上記の例のsuper（）.__ init __（self））を呼び出すと、2番目の引数クラス（self .__ class __.__ mro__）の線形化リストを調べて、このメソッドを呼び出そうとします同様に、最初の引数（クラスC）のクラスに続くすべてのクラスに対して、最初の引数（self）をパラメーターとして渡します。 つまり 私たちの場合：

self .__ class __.__ mro__ = [C、B、A、P1、P2、...]

super（C、self）.__ init __（）=> B .__ init __（self）

super（B、self）.__ init __（）=> A .__ init __（self）

super（A、self）.__ init __（）=> P1 .__ init __（self）

ご覧のとおり、B .__ init__メソッドから、superを使用すると、A .__ init__メソッドが呼び出されますが、クラスAはそれとは関係がなく、先祖ではありません。 この場合、必要に応じて、チェーンはすべての祖先のメソッドを一度に処理します。



このアプローチのおかげで、たとえば、調査対象のパイの例のすべてのコンポーネントにアレルゲンメソッドを導入できます。これは、祖先のチェーンを一貫して通過して、バイヤーに警告するためにすべてのアレルゲンコンポーネントのリストを作成します。 コンポーネントコンポーネントから継承するためだけに、各製品の「推奨されない」リストを書き換えるよりも便利です。 その後、リストが自動的に生成されます。 同様に、特定のグループから特定の減衰係数を持つジャンルまで、各製品の飲み物の選択をユーザーに提供したり、自作のインターネットラジオステーションでユーザーの好みの重みを変えたりすることができます。



円グラフの例は次のようになります（バージョン2.xの場合）：

class Food (object):

def drink(self):

return [ 'Water' , 'Cola' ]

def allergen(self):

return []



class Meat (Food):

def drink(self):

return [ 'Red wine' ] + super (Meat, self).drink()



class Milk (Food):

def allergen(self):

return [ 'Milk-protein' ] + super (Milk, self).allergen()



class Flour (Food): pass



class Rabbit (Meat):

def drink(self):

return [ 'Novello wine' ] + super (Rabbit, self).drink()



class Pork (Meat):

def drink(self):

return [ 'Sovinion wine' ] + super (Pork, self).drink()

def allergen(self):

return [ 'Pork-protein' ] + super (Pork, self).allergen()



class Pasty (Milk, Flour): pass



class Pie (Rabbit, Pork, Pasty):

def drink(self):

return [ 'Mineral water' ] + super (Pie, self).drink()



if __name__ == "__main__" :

pie = Pie()



print 'List of allergens: '

for allergen in pie.allergen(): print ' - ' + allergen



print 'List of recommended drinks: '

for drink in pie.drink(): print ' - ' + drink







その結果、次のように表示されます。

アレルゲンのリスト：

-豚肉タンパク質

-ミルクプロテイン

推奨される飲み物のリスト：

-ミネラルウォーター

-ノヴェロワイン

-ソビニオンワイン

-赤ワイン

-水

-コーラ



このリストに基づいて、線形化リストがどのように処理されたかを理解できます。 ご覧のとおり、親メソッドは2回呼び出されていません。そうでないと、アレルゲンまたは推奨のリストに繰り返しが見つかります。 さらに、最も古いクラスのFoodでは、アレルゲンと飲み物の両方のメソッドが定義されています。 super（）呼び出しはチェックを実行しないため、存在しないメソッドを呼び出そうとすると、AttributeError： 'super' object has no attribute 'allergen'のようなエラーが発生します。

線形化をコンパイルできない場合。

C3アルゴリズムを使用して線形化を構成することが不可能な場合については、すでに検討しました。 ただし、その後、子孫クラスの宣言で先祖クラスの場所を変更することで問題は解決しました。 線形化が不可能な他のケースがあります。

class C (A, B): pass

class D (B, A): pass

class E (C, D): pass







L [E] = [E] +マージ（L [C]、L [D]、[C、D]）= [E] +マージ（[C、A、B]、[D、B、A]、 [C、D]）

= [E] + [C、D] +マージ（[A、B]、[B、A]）



ご覧のとおり、宣言CではクラスAがBの前にあり、宣言Dでは逆になっているため、競合は解決されませんでした。 さて、この場所から構造を確認する必要があります。 しかし、本当に速く速くする必要がある場合、または自分が何をしているのかを知っているだけであれば、Pythonはあなたを制限しません。 メタクラスを介して独自の線形化を定義できます。 これを行うには、メタクラスでmro（cls）メソッドを指定するだけで十分です。実際、ベースメタクラスタイプのメソッドを再定義すると、必要な線形化が返されます。

class MetaMRO ( type ):

def mro(cls):

return (cls, A, B, C, D object)







さらに、バージョン3.0と2.xではクラス宣言が異なります。

class E (C, D): __metaclass__ = MetaMRO # 2.x

class E (C, D, metaclass = MetaMRO): pass # 3.0







その後、E .__ mro__ = [E、A、B、C、D、object]。 MROを担当する場合、Pythonは追加のチェックを行わず、子孫よりも先に先祖を安全に検索できることに注意してください。 これは望ましいことではありませんが、可能です。



便利なリンク：

Python 2.2での型とクラスの統合 -オブジェクトモデルとメタデータモデルの分離について。 また、MRO、多重継承の問題、およびsuper（）についても説明します。

Python 2.3メソッド解決順序 -例付きのC3アルゴリズム。 最後に、純粋なPythonでのmroおよびmerge関数の実装があり、テキストよりもコードをよく理解している人向けです。

ディランの単調スーパークラス線形化 -いくつかのタイプの線形化の比較。

あとがき。

もちろん、関連するすべてのトピックをカバーすることは不可能であり、おそらく誰かが答えよりも多くの質問を持っています。 たとえば、メタクラス、タイプとオブジェクトの基本クラスなどです。 興味がある場合は、時間が経つにつれて、私はそのようなトピックを解析しようとすることができます：

• Pythonのイントロスペクション：対話型ヘルプ、dir、sysなど。
• タイプとオブジェクト：ほとんどの場合、 これの無料の短縮された翻訳として
• Pythonの魔法：__str __、__ init __、__ new __、__ slots__など 実際、かなりたくさんあるので、いくつかの部分を見つけることができます。
• メタクラス。

PS：このトピックと個人的にGoodroneを投稿してくれたすべての人に感謝します。