python Mehrfachvererbung von verschiedenen Pfaden mit derselben Methode name

super() nur jemals lösen einer einzigen Klasse-Typ für eine bestimmte Methode, so dass, wenn Sie Erben von mehreren Klassen und möchten, rufen Sie die Methode in beiden von Ihnen, müssen Sie es explizit tun.

InformationsquelleAutor der Antwort Amber

Dank für alle, die dazu beigetragen zu diesem thread.

Zusammenfassen:

• Die (derzeit) akzeptierte Antwort ist ungenau. Die korrekte Bezeichnung sollte sein: super() ist NICHT NUR gut für die Lösung einfacher Vererbung, ABER AUCH Mehrfachvererbung. Und der Grund ist gut erklärt in @blckknght 's Kommentar:

  Während explizites aufrufen der Basisklasse Methoden arbeiten können für sehr einfache Szenarien, wie der Fragesteller die Beispiel, es wird zusammenbrechen, wenn die Basisklassen selbst Erben von einer gemeinsamen Basis, und Sie nicht wollen, dass die ultimative Basisklasse die Methode zweimal aufgerufen werden. Dies ist bekannt als "diamond-inheritance" und es ist ein großes problem für viele Mehrfachvererbung Systeme (wie in C++). Python ' s collaborative Mehrfachvererbung (mit super()) können Sie ganz einfach zu lösen ist es in vielen Fällen (aber das ist nicht zu sagen, eine Genossenschaft mehrere Hierarchie-Vererbung ist einfach zu design-oder immer eine gute Idee).

• Den richtigen Weg, wie @duncan hingewiesenist die Verwendung von super(), aber verwenden Sie es konsequent.

  super ist ja bestimmt für diese situation, aber es funktioniert nur, wenn Sie diese konsequent nutzen. Wenn der Basis-Klassen nicht auch alle nutzen super es wird nicht funktionieren, es sei denn, die Methode ist in object Sie haben, um so etwas wie eine gemeinsame Basis-Klasse zu beenden, die Kette der super Anrufe.

  class FooBase(object):
      def foo(self): pass
  
  class A(FooBase):
      def foo(self):
          super(A, self).foo()
          print 'A.foo()'
  
  class B(FooBase):
      def foo(self):
          super(B, self).foo()
          print 'B.foo()'
  
  class C(A, B):
      def foo(self):
          super(C, self).foo()
          print 'C.foo()'
  
  C().foo()  # Run this

  Aber es lohnt sich auch zu betonen, dass die Methode aufrufen Reihenfolge scheint NICHT intuitiv, der erste Gedanke. Das Ergebnis ist:

  B.foo()
  A.foo()
  C.foo()

  Diese scheinbar seltsame bestellen Den eigentlichen Aufruf, um noch C, A, B basierend auf MRO. In anderen Worten,

  super() wird, rufen Sie die Methode foo auf "vor - " "weiter" - super-Klasse. Dieses basiert auf der Methode Auflösung Um (__mro__) für die Klasse C.

  -- Zitiert und verändert aus @Manoj-Govindan 's Antwort

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

• Als eine Regel von Daumen, wenn Sie wollen, zu Reisen, um ALLE übergeordneten Methoden, aber nicht wirklich wichtig, die invoke-Bestellung, verwenden Sie super() consisently. Andernfalls können Sie wählen, um explizite Aufruf von parent-Methoden in einer bestimmten Reihenfolge.

• Nicht mischen, die Verwendung von super() und die explizite Berufung aber. Sonst werden Sie am Ende böse überschneidungen, wie bereits erwähnt, in diese Antwort.

UPDATE: Wenn Sie wollen, um zu Tauchen tiefer...

Kurz, mit super(...) konsequent in der ganzen Klasse-Familie wird dafür sorgen, ALLE gleichnamigen Methoden aus Vorfahren, die einmal aufgerufen, in der Reihenfolge der MRO. Solche call-ALL-Vorfahren (statt rufen Sie-nur-die-erste-Kandidaten) Verhalten kann begrifflich leichter zu akzeptieren, wenn die Methode, die passiert zu sein eine __init__()siehe das Beispiel in diesem blog-post.

Sagen: "Folgen Sie dem MRO, um" vielleicht nicht sehr präzise, aber. Es eigentlich immer nach dem "Enkel" 's MRO, irgendwie. Es ist faszinierend zu sehen, Sie in Aktion. Das Ergebnis folgenden Programm möglicherweise nicht genau das, was Sie dachte, es wäre. Achten Sie darauf, wie A.__mro__ bleibt die gleiche in 2 verschiedenen Aufruf-stack, aber wie super(A, self).name oder super(A, self).foo() sich ANDERS Verhalten, ausgelöst durch A().foo() und durch C().foo(). Das Ergebnis zitiert am Ende.

class FooBase(object):
    name = "FooBase"
    def foo(self):
        print('         Base.foo() begins')
        print("         My name is: %s" % self.name)
        print("         My super's name is not available")
        print('         Base.foo() ends')

class A(FooBase):
    name = "A"
    def foo(self):
        print('     A.foo() begins')
        print("     My name is: %s" % self.name)
        print("     My super's name is: %s" % super(A, self).name)
        print("     A.__mro__ is %s" % str(A.__mro__))
        super(A, self).foo()
        print('     A.foo() ends')

class B(FooBase):
    name = "B"
    def foo(self):
        print('     B.foo() begins')
        print("     My name is: %s" % self.name)
        print("     My super's name is: %s" % super(B, self).name)
        print("     B.__mro__ is %s" % str(B.__mro__))
        super(B, self).foo()
        print('     B.foo() ends')

class C(A, B):
    name = "C"
    def foo(self):
        print 'C.foo() begins'
        print("My name is: %s" % self.name)
        print("My super's name is: %s" % super(C, self).name)
        print(" C.__mro__ is %s" % str(C.__mro__))
        super(C, self).foo()
        print('C.foo() ends')


print("We will call A.foo()")
A().foo()

print("We will call C.foo()")
C().foo()  # Run this to see how each foo() is called ONLY ONCE

Und das Ergebnis von Python 2.7.12 ist:

We will call A.foo()
     A.foo() begins
     My name is: A
     My super's name is: FooBase
     A.__mro__ is (<class '__main__.A'>, <class '__main__.FooBase'>, <type 'object'>)
         Base.foo() begins
         My name is: A
         My super's name is not available
         Base.foo() ends
     A.foo() ends
We will call C.foo()
C.foo() begins
My name is: C
My super's name is: A
 C.__mro__ is (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.FooBase'>, <type 'object'>)
     A.foo() begins
     My name is: C
     My super's name is: B
     A.__mro__ is (<class '__main__.A'>, <class '__main__.FooBase'>, <type 'object'>)
     B.foo() begins
     My name is: C
     My super's name is: FooBase
     B.__mro__ is (<class '__main__.B'>, <class '__main__.FooBase'>, <type 'object'>)
         Base.foo() begins
         My name is: C
         My super's name is not available
         Base.foo() ends
     B.foo() ends
     A.foo() ends
C.foo() ends

InformationsquelleAutor der Antwort RayLuo

Wenn Sie Hinzugefügt haben, die folgenden:

class A(object):
    def foo(self):
        print 'A.foo()'

class B(object):
    def foo(self):
        print 'B.foo()'

class C(A, B):
    def foo(self):
        super(C, self).foo()
        print 'C.foo()'
        A.foo(self)
        B.foo(self)


c = C()
c.foo()

Dann super(C, selbst).foo() bezieht sich auf A. foo

Die Ausgabe ist

A.foo()
C.foo()
A.foo()
B.foo()

[Edit: zusätzliche Informationen und links]

• Grundlegendes zu Python super() mit __init__ () - Methoden
• http://www.artima.com/weblogs/viewpost.jsp?thread=237121

InformationsquelleAutor der Antwort pyfunc

Dies ist möglich mit super

class A(object):
    def foo(self):
        print 'A.foo()'

class B(object):
    def foo(self):
        print 'B.foo()'

class C(A, B):
    def foo(self):
        print 'C.foo()'
        super(C, self).foo() # calls A.foo()
        super(A, self).foo() # calls B.foo()

InformationsquelleAutor der Antwort acktus