Detaillierte Erklärung der Python-Mehrfachvererbung

class A(object):    # A must be new-style class
   def __init__(self):
    print "enter A"
    print "leave A"
  
class B(C):     # A --> C
   def __init__(self):
    print "enter B"
    super(B, self).__init__()
    print "leave B"

Nach unserem Eindruck wird super(B, self).__init__() so verstanden: super(B, self) findet zuerst die übergeordnete Klasse von B (also Klasse A) und fügt dann die Klasse ein B in Das Objekt selbst wird in ein Objekt der Klasse A konvertiert, und dann ruft das „konvertierte“ Objekt der Klasse A seine eigene __init__-Funktion auf.

Eines Tages entwarf ein Kollege eine relativ komplexe Klassensystemstruktur (machen wir uns keine Gedanken darüber, ob das Klassensystemdesign sinnvoll ist oder nicht, studieren Sie einfach dieses Beispiel als Thema), der Code lautet wie folgt

Codesegment 4:

class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"
  
class B(object):
    def __init__(self):
        print "enter B"
        print "leave B"
  
class C(A):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"
  
class D(A):
    def __init__(self):
        print "enter D"
        super(D, self).__init__()
        print "leave D"
        class E(B, C):
        def __init__(self):
        print "enter E"
        B.__init__(self)
        C.__init__(self)
        print "leave E"
  
class F(E, D):
    def __init__(self):
        print "enter F"
        E.__init__(self)
        D.__init__(self)
        print "leave F"

f = F(), das Ergebnis ist wie folgt:

Eingabe von F, Eingabe von E, Eingabe von B, Verlassen von B, Eingabe von C, Eingabe von D, Eingabe von A verlassen A verlassen D verlassen C verlassen E betreten D betreten A verlassen A verlassen D verlassen F

Offensichtlich werden die Initialisierungsfunktionen von Klasse A und Klasse D zweimal aufgerufen Gewünschte Ergebnisse! Das erwartete Ergebnis ist, dass die Initialisierungsfunktion der Klasse A höchstens zweimal aufgerufen wird – tatsächlich ist dies ein Problem, mit dem Systeme mit mehreren Vererbungsklassen konfrontiert sind. Wir zeichnen das Klassensystem von Codesegment 4, wie unten gezeigt:

Objekt
| E |
|
F

Nach unserem Verständnis von Super kann es Aus der Abbildung ist ersichtlich, dass beim Aufrufen der Initialisierungsfunktion der Klasse C die Initialisierungsfunktion der Klasse A aufgerufen werden sollte, tatsächlich jedoch Aber die Initialisierungsfunktion der Klasse D wird aufgerufen. Was für eine seltsame Frage!

Das heißt, mro zeichnet die Klassentypsequenz aller Basisklassen einer Klasse auf. Als wir uns die Aufzeichnung von MRO ansahen, stellten wir fest, dass sie 7 Elemente enthält und die 7 Klassennamen lauten:

F E B C D A object

> Dies erklärt, warum super(C, self) in C verwendet wird .__init__. __init__() ruft die Initialisierungsfunktion der Klasse D auf. ???

Wir schreiben Codesegment 4 um als:

Codesegment 5:

f = F(), Ausführungsergebnis:

F eingeben, E eingeben, B eingeben, C eingeben, D eingeben, A eingeben, A verlassen, D verlassen, C verlassen, B verlassen, E verlassen, F verlassen

class A(object):
    def __init__(self):
        print "enter A"
        super(A, self).__init__()  # new
        print "leave A"
  
class B(object):
    def __init__(self):
        print "enter B"
        super(B, self).__init__()  # new
        print "leave B"
  
class C(A):
    def __init__(self):
        print "enter C"
        super(C, self).__init__()
        print "leave C"
  
class D(A):
    def __init__(self):
        print "enter D"
        super(D, self).__init__()
        print "leave D"
        class E(B, C):
        def __init__(self):
        print "enter E"
        super(E, self).__init__()  # change
        print "leave E"
  
class F(E, D):
    def __init__(self):
        print "enter F"
        super(F, self).__init__()  # change
        print "leave F"

Es ist ersichtlich, dass die Initialisierung von F nicht nur alle Anrufe an das übergeordnete Element abschließt Klasse, aber auch Es ist garantiert, dass die Initialisierungsfunktion jeder übergeordneten Klasse nur einmal aufgerufen wird.

Zusammenfassung

1. super ist keine Funktion, sondern ein Klassenname. Die Form super(B, self) ruft tatsächlich die Initialisierungsfunktion der Superklasse auf,
Ein Superobjekt wird generiert;

2. Die Initialisierungsfunktion der Superklasse führt keine speziellen Operationen aus, sondern zeichnet lediglich den Klassentyp und bestimmte Instanzen auf.

3. Der Aufruf von super(B, self). func wird nicht verwendet, um die func-Funktion der übergeordneten Klasse der aktuellen Klasse aufzurufen.

4. Die mehrfach vererbten Klassen von Python stellen sicher, dass die Funktionen jeder übergeordneten Klasse einzeln aufgerufen werden jede übergeordnete Klassenfunktion

wird nur einmal aufgerufen (wenn jede Klasse super verwendet); 5. Das Mischen von Superklassen und ungebundenen Funktionen ist ein gefährliches Verhalten, das dazu führen kann, dass die übergeordnete Klassenfunktion, die aufgerufen werden sollte, nicht aufgerufen wird oder a
übergeordnete Klasse Die Funktion wird mehrmals aufgerufen.

Einige detailliertere Fragen: Wie Sie sehen können, wird beim Drucken von F.__mro__ festgestellt, dass die Reihenfolge der darin enthaltenen Elemente F E B C D A-Objekt ist. Dies ist die Suchreihenfolge der Basisklasse von F. Was Warum es in dieser Reihenfolge ist und wie die integrierte Mehrfachvererbungssequenz implementiert wird, umfasst die Implementierung der MRO-Sequenz. Versionen nach Python 2.3 verwenden einen Algorithmus namens C3, der im nächsten Blog vorgestellt wird.