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 B Die übergeordnete Klasse ( Das heißt, Klasse A), konvertiert dann das Objektselbst der Klasse B in ein Objekt der Klasse A, 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:

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

Offensichtlich wurden die Initialisierungsfunktionen von Klasse A und Klasse D zweimal aufgerufen, was nicht das Ergebnis ist, das wir erwartet hatten! 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:

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"

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

Es ist ersichtlich, dass die Initialisierung von F ist nicht nur abgeschlossen. Es eliminiert alle Aufrufe der übergeordneten Klasse und stellt sicher, 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 ist es in dieser Reihenfolge und wie Python die integrierte Mehrfachvererbungssequenz implementiert, die die Implementierung der MRO-Sequenz beinhaltet,