Aufruf einer übergeordneten Klasse die Methode von der Kind-Klasse in Python?

Beim erstellen einer einfachen Objekt-Hierarchie in Python, ich möchte in der Lage zum aufrufen von Methoden von der übergeordneten Klasse, von der eine abgeleitete Klasse. In Perl und Java, es ist ein Schlüsselwort für diese (super). In Perl könnte ich dies tun:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

sub frotz {
   my $str = SUPER::frotz();
   return uc($str);
}

In python, scheint es, dass ich den Namen der Elternklasse explizit vom Kind.
In dem Beispiel oben, ich hätte etwas zu tun, wie Foo::frotz().

Dieser scheint nicht richtig, da dieses Verhalten macht es schwer, zu Tiefe Hierarchien. Wenn Kinder müssen wissen, welche Klasse definiert eine geerbte Methode, dann werden alle Arten von Informationen, die Schmerz erzeugt.

Ist dies eine tatsächliche Einschränkung in python, eine Lücke in meinem Verständnis oder beides?

Ich denke, die Benennung der übergeordneten Klasse ist nicht so eine schlechte Idee. Es kann helfen, wenn die Kind-Klasse erbt von mehr als einem Elternteil, da Sie explizit den Namen der übergeordneten Klasse.
Während Sie eine option, um den Namen einer Klasse ist keine schlechte Idee, gezwungen zu tun, so sicher ist.
Sich bewusst sein, der Veränderungen in der super-handling zwischen Python 2 und Python 3 https://www.python.org/dev/peps/pep-3135/. Die Benennung der Klasse ist nicht mehr erforderlich (obwohl vielleicht noch ein Gott Idee, zumindest manchmal).

InformationsquelleAutor jjohn | 2009-04-30

598

Ja, aber nur mit new-style-Klassen. Verwenden Sie die super() Funktion:
```
class Foo(Bar):
    def baz(self, arg):
        return super(Foo, self).baz(arg)
```
Können Sie nicht auch "return Bar.baz(self, arg)"? Wenn ja, welche wäre besser?
Ja, Sie können, aber die OP wurde gefragt, wie es zu tun, ohne ausdrücklich die Benennung der Oberklasse an der call-site (Bar, in diesem Fall).
super() ist komisch mit Mehrfachvererbung. Er fordert die "nächste" Klasse. Das könnte der übergeordneten Klasse, oder vielleicht einige völlig unabhängig von der Klasse, die erscheint an anderer Stelle in der Hierarchie.
Ich verwende Python-2.x und ich erhalte die Meldung "Fehler: Sie müssen geben, nicht classobj" wenn ich dies tun
Die syntax super(Foo, self) ist für Python 2.x richtig? In Python 3.x, die super() wird bevorzugt, richtig?

InformationsquelleAutor Adam Rosenfield
125

Python hat auch super:

super(type[, object-or-type])

Rückkehr ein proxy-Objekt, dass die Delegierten, die Methodenaufrufe an ein Elternteil oder Geschwister Klasse der Typ.
Dies ist nützlich für den Zugriff auf geerbte Methoden, die übergangen wurden, in eine Klasse.
Die Suchreihenfolge ist dieselbe wie die von getattr (), außer dass der Typ selbst wird übersprungen.

Beispiel:
```
class A(object):     # deriving from 'object' declares A as a 'new-style-class'
    def foo(self):
        print "foo"

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

myB = B()
myB.foo()
```
Besseres Beispiel, als Adam, weil du Sie bereits mit einer new-style Klasse mit dem Objekt-Basisklasse. Nur fehlt der link zu " new-style-Klassen.

InformationsquelleAutor Jay
78
```
ImmediateParentClass.frotz(self)
```
wird in Ordnung sein, ob der direkt übergeordneten Klasse definiert frotz selbst oder es geerbt. super ist nur erforderlich für die ordnungsgemäße Unterstützung von mehrere Vererbung (und dann funktioniert es nur, wenn jede Klasse nutzt es richtig). Im Allgemeinen AnyClass.whatever Aussehen wird bis whatever im AnyClass's Vorfahren, wenn AnyClass nicht definieren/überschreiben, und das gilt für "das Kind in der Klasse den Aufruf von parent - Methode" ebenso wie für alle anderen vorkommen!

Dies bedeutet, dass die ImmediateParentClass auch im Bereich dieser Anweisung ausgeführt werden. Nur dass das Objekt aus einem Modul importiert wird nicht helfen.
was ist, wenn seine Methode einer Klasse?

InformationsquelleAutor Alex Martelli
62

Python 3 hat eine andere und einfachere syntax für den Aufruf von parent-Methode.

Wenn Foo Klasse erbt von Bar, dann von Bar.__init__ können aufgerufen werden, aus Foo über super().__init__():
```
class Foo(Bar):

    def __init__(self, *args, **kwargs):
        # invoke Bar.__init__
        super().__init__(*args, **kwargs)
```
Gut zu hören, python 3 hat eine bessere Lösung. Die Frage kommt von python 2.X. Danke für den Vorschlag aber.

InformationsquelleAutor Arun Ghosh
33

Viele Antworten haben erklärt, wie das aufrufen einer Methode aus der übergeordneten, die außer Kraft gesetzt wurde, in das Kind.

Jedoch

"wie nennt man einen übergeordneten Klasse die Methode aus der abgeleiteten Klasse?"

könnte auch einfach bedeuten:

"wie nennt man geerbte Methoden?"

Aufrufen Sie können geerbte Methoden von einer übergeordneten Klasse, so als wären Sie Methoden der Kind-Klasse, solange Sie noch nicht überschrieben wurden.

z.B. in python 3:
```
class A():
  def bar(self, string):
    print("Hi, I'm bar, inherited from A"+string)

class B(A):
  def baz(self):
    self.bar(" - called by baz in B")

B().baz() # prints out "Hi, I'm bar, inherited from A - called by baz in B"
```
ja, das kann ziemlich offensichtlich, aber ich glaube, ohne näher auf diese Menschen verlassen kann, dieses Thema mit dem Eindruck, den Sie haben zu springen durch lächerlich Reifen nur Zugriff auf geerbte Methoden in python. Vor allem, da diese Frage Preisen hoch in der sucht ", wie Sie Zugang zu einer übergeordneten Klasse die Methode in Python", und die OP ist geschrieben aus der Perspektive von jemand, der neu in python.

Ich gefunden:
https://docs.python.org/3/tutorial/classes.html#inheritance
um nützlich zu sein, zu verstehen, wie Sie Zugriff auf geerbte Methoden.

Dies ist genau das, was ich wissen will. Vielen Dank 🙂
in welcher situation funktioniert das nicht? Ich bin glücklich, hinzufügen, Vorsichtsmaßnahmen oder Warnungen, die relevant sind, aber ich konnte nicht herausfinden, wie der link, den Sie geschrieben wurde, relevant zu dieser Antwort.
Sorry, habe ich nicht gelesen, Ihre Antwort sorgfältig genug. Diese Antwort keine Antwort auf die Frage, wie der überlastung der Funktionen, aber die Antwort auf eine andere Frage. Ich löschte meinen ersten Kommentar.
ah, keine sorgen. Mir ist klar, dass diese Antwort nicht gelten zu überladen von Funktionen, jedoch ist die Frage nicht explizit erwähnt überlastung (obwohl das perl-Beispiel zeigt einen Fall von überlastung). Die überwiegende Mehrheit der anderen Antworten decken überlastung - diese ist hier für diejenigen, die es nicht brauchen.
was ist, wenn ich anrufen möchte (B).baz() aus einer anderen Klasse mit dem Namen 'C' mit vars definiert, die in C?. Ich habe versucht zu tun, B().baz() in der Klasse C, wo selbst.string ist ein weiterer val. Es gab mir keine, wenn ich ausgeführt

InformationsquelleAutor Ben

Hier ist ein Beispiel für die Verwendung super():

#New-style classes inherit from object, or from another new-style class
class Dog(object):

    name = ''
    moves = []

    def __init__(self, name):
        self.name = name

    def moves_setup(self):
        self.moves.append('walk')
        self.moves.append('run')

    def get_moves(self):
        return self.moves

class Superdog(Dog):

    #Let's try to append new fly ability to our Superdog
    def moves_setup(self):
        #Set default moves by calling method of parent class
        super(Superdog, self).moves_setup()
        self.moves.append('fly')

dog = Superdog('Freddy')
print dog.name # Freddy
dog.moves_setup()
print dog.get_moves() # ['walk', 'run', 'fly']. 
#As you can see our Superdog has all moves defined in the base Dog class

Ist das nicht ein schlechtes Beispiel? Ich glaube, es ist nicht wirklich sicher in der Anwendung Super, es sei denn, Ihre ganze Hierarchie ist "new style" - Klassen und ordnungsgemäß Aufruf von Super().init()

InformationsquelleAutor yesnik

13

Es ist ein super() in Python auch. Es ist ein bisschen wackelig, weil der Python ' s old - und new-style-Klassen, aber ist ziemlich Häufig verwendet, z.B. in Konstruktoren:
```
class Foo(Bar):
    def __init__(self):
        super(Foo, self).__init__()
        self.baz = 5
```
Ich denke du meinst: 'super(Foo, self).__init__()'
Hoppla... tatsächlich habe ich

InformationsquelleAutor lawrence
9

Ich würde empfehlen, mit CLASS.__bases__
so etwas
```
class A:
   def __init__(self):
        print "I am Class %s"%self.__class__.__name__
        for parentClass in self.__class__.__bases__:
              print "   I am inherited from:",parentClass.__name__
              #parentClass.foo(self) <- call parents function with self as first param
class B(A):pass
class C(B):pass
a,b,c = A(),B(),C()
```
Ich war auf der Suche nach etwas zu sagen mir die Grundlagen Klassen. Gefunden hier. Danke!
Bedenken Sie, dass, wie Sie sagen können, aus der Menge von Referenzen auf super hier, die Leute sind wirklich ungern verwenden Grundlagen, es sei denn, Sie tun etwas wirklich tief. Wenn Sie nicht wie super suchen Instandhaltung. Wobei der erste Eintrag im Instandhaltung ist sicherer als die tracking-Eintrag in den Grundlagen zu verwenden. Mehrfachvererbung in Python durchsucht bestimmte Dinge rückwärts und die andere vorwärts, so lassen sich die Sprache erholen, der Prozess ist sichersten.

InformationsquelleAutor Joran Beasley
6

Wenn Sie nicht wissen, wie viele Argumente, die Sie bekommen könnten, und wollen, Sie alle durch, das Kind als gut:
```
class Foo(bar)
    def baz(self, arg, *args, **kwargs):
        # ... Do your thing
        return super(Foo, self).baz(arg, *args, **kwargs)
```
(Aus: Python - Sauberste Möglichkeit zum überschreiben der __init__, wo eine optionale kwarg muss verwendet werden, nach dem super () - Aufruf?)

InformationsquelleAutor Robin Winslow

Es ist ein super() in python auch.

Beispiel dafür, wie ein super-Klasse-Methode aufgerufen, die eine sub-Klasse Methode

class Dog(object):
    name = ''
    moves = []

    def __init__(self, name):
        self.name = name

    def moves_setup(self,x):
        self.moves.append('walk')
        self.moves.append('run')
        self.moves.append(x)
    def get_moves(self):
        return self.moves

class Superdog(Dog):

    #Let's try to append new fly ability to our Superdog
    def moves_setup(self):
        #Set default moves by calling method of parent class
        super().moves_setup("hello world")
        self.moves.append('fly')
dog = Superdog('Freddy')
print (dog.name)
dog.moves_setup()
print (dog.get_moves())

Dieses Beispiel ist ähnlich zu der oben erklärt.Jedoch gibt es ein Unterschied ist, dass super keine Argumente übergeben werden.Dieser obige code ist ausführbar in python 3.4 version.

InformationsquelleAutor kkk

1

In Python 2, ich hatte nicht viel Glück mit super(). Ich benutzte die Antwort aus
jimifiki auf diesen SO-thread wie finden Sie zu einer übergeordneten Methode in python?.
Dann habe ich meine eigene kleine Wendung, die ich denke, ist eine Verbesserung in der Benutzerfreundlichkeit (vor Allem, wenn Sie lange Klassennamen).

Definieren, die Basis-Klasse in einem Modul:
```
 # myA.py

class A():     
    def foo( self ):
        print "foo"
```
Dann importieren Sie die Klasse in einer anderen Module as parent:
```
# myB.py

from myA import A as parent

class B( parent ):
    def foo( self ):
        parent.foo( self )   # calls 'A.foo()'
```
Verwenden Sie class A(object): statt class A(): Dann super() funktioniert
Ich bin mir nicht sicher, ob ich Folgen. Meinst du in der definition der Klasse? Offensichtlich, Sie haben, um anzugeben, dass eine Klasse ein Elternteil hat, irgendwie um zu denken, du könntest zu finden ein Elternteil! Seit ich dies geschrieben vor 9 Monaten, ich bin n bisschen unscharf, die details, aber ich denke, ich meinte die Beispiele von Arun Ghosh, lawrence, kkk usw. nicht anwendbar in Py 2.x. Stattdessen ist hier eine Methode, die funktioniert und einen einfachen Weg zu finden um die Eltern, so ist es ein wenig klarer, was du tust. (wie super)

InformationsquelleAutor BuvinJ

class department:
    campus_name="attock"
    def printer(self):
        print(self.campus_name)

class CS_dept(department):
    def overr_CS(self):
        department.printer(self)
        print("i am child class1")

c=CS_dept()
c.overr_CS()

InformationsquelleAutor maryam mehboob

-3
```
class a(object):
    def my_hello(self):
        print "hello ravi"

class b(a):
    def my_hello(self):
    super(b,self).my_hello()
    print "hi"

obj = b()
obj.my_hello()
```
Herzlich willkommen auf stackoverflow. Diese Frage wurde bereits beantwortet, in den details fast zehn Jahren nun, die Antwort akzeptiert und weitgehend von Ihnen positiv bewertet werden, und Ihre Antwort nicht etwas neues hinzufügen. Sie möchten möglicherweise versuchen Sie es und beantworten neueren (und vorzugsweise unbeantwortete) Fragen statt. As a side note, gibt es eine Schaltfläche im editor anwenden der richtigen code-Formatierung.

InformationsquelleAutor RAVIKUMAR RACHA
-22

Dies ist eine weitere abstrakte Methode:
```
super(self.__class__,self).baz(arg)
```
self.__Klasse__ nicht richtig funktioniert mit super als self ist immer die Instanz, und seine Klasse wird immer die Instanz der Klasse. Dies bedeutet, wenn Sie verwenden Sie super(self.__Klasse__.. eine Klasse und diese Klasse vererbt wird, dass es nicht mehr funktioniert.
Nur um zu verdeutlichen, VERWENDEN Sie DIESEN CODE NICHT. Es Niederlagen der ganze Zweck von super(), die ist richtig durchqueren die Instandhaltung.
stackoverflow.com/a/19257335/419348 sagte, warum nicht nennen super(self.__class__, self).baz(arg).

InformationsquelleAutor user806071

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.