Wie funktioniert Python ' s super() Arbeit mit Mehrfachvererbung?

Dies ist detaillierten mit einen angemessenen Betrag von detail von Guido, der sich in seinem blog-post Methode Auflösung Um (einschließlich zwei frühere versuche).

In deinem Beispiel Third() rufen First.__init__. Python sieht für jedes Attribut in der Klasse, die Eltern wie Sie aufgelistet sind, von Links nach rechts. In diesem Fall suchen wir für __init__. Also, wenn Sie definieren

class Third(First, Second):
    ...

Python wird beginnen, suchen Sie in First, und, wenn First nicht das Attribut, dann wird es schauen Second.

Diese situation wird komplexer, wenn die Vererbung beginnt Kreuzung Pfade (zum Beispiel, wenn First geerbt von Second). Lesen Sie den link oben für weitere details, aber in einer nussschale, Python werden versuchen, pflegen Sie die Reihenfolge, in der jede Klasse wird auf die Vererbung Liste, beginnend mit der Kind-Klasse selbst.

So, zum Beispiel, wenn Sie hatte:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First):
    def __init__(self):
        print "third"

class Fourth(Second, Third):
    def __init__(self):
        super(Fourth, self).__init__()
        print "that's it"

MRO wäre [Fourth, Second, Third, First].

Übrigens: wenn Python nicht finden können, eine kohärente Methode Auflösung um, werde es zu einer Ausnahme, statt zu fallen zurück auf das Verhalten, die vielleicht überraschen die Nutzer.

Bearbeitet, um hinzufügen ein Beispiel für eine mehrdeutige MRO:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        print "third"

Sollte Third's MRO werden [First, Second] oder [Second, First]? Es gibt keine eindeutige Erwartung, und Python wird ein Fehler ausgelöst:

TypeError: Error when calling the metaclass bases
    Cannot create a consistent method resolution order (MRO) for bases Second, First

Edit: ich sehe einige Leute argumentieren, dass die obigen Beispiele fehlen super() ruft, so lassen Sie mich erklären: Der Sinn der Beispiele ist zu zeigen, wie der MRO-konstruiert wird. Sie sind nicht soll print "first\nsecond\Dritte" oder was auch immer. Sie können – und sollten, natürlich, spielen, um mit dem Beispiel, fügen Sie super() Anrufe, sehen, was passiert, und ein tieferes Verständnis von Python-Vererbung-Modell. Aber mein Ziel ist es einfach zu halten und zu zeigen, wie der MRO-gebaut wird. Und es wird gebaut wie ich schon erklärt habe:

>>> Fourth.__mro__
(<class '__main__.Fourth'>,
 <class '__main__.Second'>, <class '__main__.Third'>,
 <class '__main__.First'>,
 <type 'object'>)

InformationsquelleAutor rbp

Ich wollte aufwändige die Antwort von leblos ein bisschen, weil wenn ich anfing zu Lesen über die Verwendung von super() in einer mehrfach-Hierarchie-Vererbung in Python, habe ich nicht bekommen es sofort.

Was Sie verstehen müssen ist, dass super(MyClass, self).__init__() bietet die nächsten __init__ Methode, nach der Methode Auflösung Bestellen (MRO) - Algorithmus im Kontext der kompletten Vererbungshierarchie.

Dieser Letzte Teil ist entscheidend, um zu verstehen. Wir betrachten nochmals das Beispiel:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

Laut diesem Artikel über die Methode Auflösung Um , die von Guido van Rossum, der, um zu beheben __init__ berechnet (vor Python 2.3) mit einer "Tiefe-zuerst, Links-nach-rechts-traversal" :

Third --> First --> object --> Second --> object

Nach dem entfernen aller Duplikate, mit Ausnahme der letzten, die wir bekommen :

Third --> First --> Second --> object

So, können verfolgen, was passiert, wenn wir instanziieren eine Instanz der Third Klasse, z.B. x = Third().

1. Gemäß MRO __init__ Dritter zum ersten mal aufgerufen wird.

2. Nächsten, gemäß MRO innen der __init__ Methode super(Third,
self).__init__() löst die __init__ Methode der Ersten, die
   wird aufgerufen.

3. Innen __init__ des Ersten super(First, self).__init__() ruft die __init__ von Zweiten, weil das ist, was der MRO-Diktat!

4. Innen __init__ des Zweiten super(Second, self).__init__() Anrufe
   die __init__ des Objekts, die Beträge zu nichts. Danach
   "zweite" ist gedruckt.

5. Nach super(First, self).__init__() abgeschlossen,
   "zuerst" wird gedruckt.

6. Nach super(Third, self).__init__() abgeschlossen, ", dass es" gedruckt.

Diese details heraus, warum die Instanziierung Dritten() führt zu :

>>> x = Third()
second
first
that's it

MRO-Algorithmus wurde verbessert von Python 2.3 weiter zu arbeiten, auch in komplexen Fällen, aber ich denke, das mit der "Tiefe-zuerst, Links-nach-rechts-traversal" + "entfernen der Duplikate erwarten für das Letzte" noch funktioniert in den meisten Fällen (bitte kommentieren, wenn dies nicht der Fall ist). Lesen Sie den blog-post von Guido!

InformationsquelleAutor Visionscaper

Dies ist, wie ich die lösen in der Frage der Notwendigkeit von Mehrfachvererbung mit verschiedenen Variablen für die Initialisierung und mehrere Mixins in Verbindung mit dem gleichen Funktionsaufruf. Ich hatte explizit hinzufügen von Variablen zu übergeben, **kwargs und fügen Sie ein MixIn-interface ein Endpunkt für die super Gespräche.

Hier A ist eine erweiterbare Basis-Klasse und B und C sind MixIn-Klassen sowohl die Funktion f. A und B beide erwarten parameter v in Ihrer __init__ und C erwartet w.
Die Funktion f nimmt einen parameter y. Q erbt von allen drei Klassen. MixInF wird das mixin-interface für B und C.

• IPython NoteBook Dieser Code
• Github Repo mit code Beispiel

class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

InformationsquelleAutor brent.payne

Insgesamt

Vorausgesetzt, alles stammt aus object (Sie sind auf Ihre eigenen, wenn es nicht), Python berechnet eine Methode die Auflösung von Ordnung (MRO), basierend auf Ihrer Klasse vererbungsbaums. Der MRO-erfüllt 3 Eigenschaften:

• Kinder einer Klasse kommen, bevor Ihre Eltern
• Links kommen die Eltern vor dem Recht der Eltern
• Eine Klasse nur einmal in der MRO -

Wenn keine solche Reihenfolge gibt es, Python-Fehler aufgetreten. Das Innenleben ist dies eine C3-Linearisierung der Klassen Abstammung. Lesen Sie alles über es hier: https://www.python.org/download/releases/2.3/mro/

So, in beiden der folgenden Beispiele ist es:

1. Kind
2. Links
3. Recht
4. Eltern

Wenn eine Methode aufgerufen wird, wird das erste vorkommen dieser Methode in der Instandhaltung ist die, die aufgerufen wird. Jede Klasse, die nicht realisieren, dass die Methode übersprungen. Jeder Aufruf super innerhalb der Methode ruft die nächste Instanz, das Verfahren in der Instandhaltung. Folglich, es ist wichtig zu haben, was um Sie Platz Klassen in der Vererbung, und wo Sie die Anrufe zu super in den Methoden.

Mit super ersten in jeder Methode

class Parent(object):
    def __init__(self):
        super(Parent, self).__init__()
        print "parent"

class Left(Parent):
    def __init__(self):
        super(Left, self).__init__()
        print "left"

class Right(Parent):
    def __init__(self):
        super(Right, self).__init__()
        print "right"

class Child(Left, Right):
    def __init__(self):
        super(Child, self).__init__()
        print "child"

Child() Ausgänge:

parent
right
left
child

Mit super letzten in jeder Methode

class Parent(object):
    def __init__(self):
        print "parent"
        super(Parent, self).__init__()

class Left(Parent):
    def __init__(self):
        print "left"
        super(Left, self).__init__()

class Right(Parent):
    def __init__(self):
        print "right"
        super(Right, self).__init__()

class Child(Left, Right):
    def __init__(self):
        print "child"
        super(Child, self).__init__()

Child() Ausgänge:

child
left
right
parent

InformationsquelleAutor Zags

Weiteren noch nicht erfassten Punkt ist die übergabe von Parametern für die Initialisierung von Klassen. Da das Ziel der super hängt von der Unterklasse die einzige gute Möglichkeit für die übergabe von Parametern packt Sie alle zusammen. Dann werden Sie vorsichtig, um nicht die gleichen parameter name mit verschiedenen Bedeutungen.

Beispiel:

class A(object):
    def __init__(self, **kwargs):
        print('A.__init__')
        super().__init__()

class B(A):
    def __init__(self, **kwargs):
        print('B.__init__ {}'.format(kwargs['x']))
        super().__init__(**kwargs)


class C(A):
    def __init__(self, **kwargs):
        print('C.__init__ with {}, {}'.format(kwargs['a'], kwargs['b']))
        super().__init__(**kwargs)


class D(B, C): # MRO=D, B, C, A
    def __init__(self):
        print('D.__init__')
        super().__init__(a=1, b=2, x=3)

print(D.mro())
D()

gibt:

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D.__init__
B.__init__ 3
C.__init__ with 1, 2
A.__init__

Aufruf der super-Klasse __init__ direkt für mehr direkte Zuordnung von Parametern ist verlockend, aber schlägt fehl, wenn es irgendeine super Aufruf in einer super-Klasse und/oder die Instandhaltung wird geändert und die Klasse A kann mehrfach aufgerufen werden, abhängig von der Implementierung.

Schließen: kooperative Vererbung und super und spezifische Parameter für die Initialisierung arbeiten nicht sehr gut zusammen.

InformationsquelleAutor Trilarion

Ich hinzufügen möchte, was @Visionscaper sagt an der Spitze:

Third --> First --> object --> Second --> object

In diesem Fall wird der interpreter nicht herausfiltern, die das Objekt der Klasse, weil seine dupliziert, sondern seine weil der Zweite erscheint in einer Kopf-position und nicht erscheint in den Schwanz position in einer Hierarchie Teilmenge. Während Objekt erscheint nur in der Schwanz-Positionen und ist nicht als eine starke position in C3-Algorithmus, um zu bestimmen, Priorität.

Die Linearisierung(mro) von der Klasse C L(C), ist die

• der Klasse C
• plus das Zusammenführen der
  • Linearisierung von seinen Eltern P1, P2, .. = L(P1, P2, ...) und
  • die Liste seiner Eltern P1, P2, ..

Linearisierte Zusammenführen wird durch Auswahl des gemeinsamen Klassen, der aussieht wie der Kopf von Listen-und nicht der Schwanz da, um Fragen(wird klar, unten)

Die Linearisierung von Dritten berechnet werden kann wie folgt:

    L(O)  := [O]  // the linearization(mro) of O(object), because O has no parents

    L(First)  :=  [First] + merge(L(O), [O])
               =  [First] + merge([O], [O])
               =  [First, O]

    // Similarly, 
    L(Second)  := [Second, O]

    L(Third)   := [Third] + merge(L(First), L(Second), [First, Second])
                = [Third] + merge([First, O], [Second, O], [First, Second])
// class First is a good candidate for the first merge step, because it only appears as the head of the first and last lists
// class O is not a good candidate for the next merge step, because it also appears in the tails of list 1 and 2, 
                = [Third, First] + merge([O], [Second, O], [Second])
// class Second is a good candidate for the second merge step, because it appears as the head of the list 2 and 3
                = [Third, First, Second] + merge([O], [O])            
                = [Third, First, Second, O]

Somit für einen super () - Implementierung in dem folgenden code:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

wird deutlich, wie diese Methode gelöst werden

Third.__init__() ---> First.__init__() ---> Second.__init__() ---> 
Object.__init__() ---> returns ---> Second.__init__() -
prints "second" - returns ---> First.__init__() -
prints "first" - returns ---> Third.__init__() - prints "that's it"

InformationsquelleAutor supi

Vielleicht gibt es noch etwas, das Hinzugefügt werden kann, ein kleines Beispiel mit Django rest_framework und Dekorateure. Dies bietet eine Antwort auf die implizite Frage: "warum möchte ich das überhaupt?"

Wie gesagt: wir sind mit Django rest_framework, und wir sind mit Hilfe von generischen Ansichten, und für jede Art von Objekten in unserer Datenbank finden wir uns mit einer view-Klasse, die Bereitstellung von GET-und POST für Listen von Objekten, und eine andere Ansicht-Klasse bietet GET, PUT und DELETE für einzelne Objekte.

Nun die POST, PUT und DELETE wir wollen zu dekorieren mit Django ' s login_required. Beachten Sie, wie diese berührt sowohl Klassen, aber nicht alle Methoden in beiden Klassen.

Könnte eine Lösung gehen, die durch Mehrfachvererbung.

from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required

class LoginToPost:
    @method_decorator(login_required)
    def post(self, arg, *args, **kwargs):
        super().post(arg, *args, **kwargs)

Ebenso für die anderen Methoden.

In der Vererbung Liste meiner konkreten Klassen, ich möchte hinzufügen, meine LoginToPost vor ListCreateAPIView und LoginToPutOrDelete vor RetrieveUpdateDestroyAPIView. Meine konkrete Klassen' get bleiben würde, schmucklos.

InformationsquelleAutor mariotomo