Wie rufe ich die Methode einer Elternklasse von einer Kindklasse in Python auf?

Question

Bei der Erstellung einer einfachen Objekthierarchie in Python möchte ich die Methoden der übergeordneten Klasse von einer abgeleiteten Klasse aus aufrufen können. In Perl und Java gibt es dafür ein Schlüsselwort ( 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 die übergeordnete Klasse explizit nach der untergeordneten benennen muss. In dem obigen Beispiel müsste ich etwas tun wie Foo::frotz() .

Dies scheint nicht richtig zu sein, da dieses Verhalten es schwierig macht, tiefe Hierarchien zu erstellen. Wenn Kinder wissen müssen, welche Klasse eine geerbte Methode definiert hat, entstehen alle Arten von Informationsschmerzen.

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

Answer 1

Verwenden Sie die super() Funktion:

class Foo(Bar):
    def baz(self, **kwargs):
        return super().baz(**kwargs)

Für Python < 3 müssen Sie sich ausdrücklich für die Verwendung von Klassen im neuen Stil und verwenden:

class Foo(Bar):
    def baz(self, arg):
        return super(Foo, self).baz(arg)

Answer 2

Python hat auch super auch:

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

Gibt ein Proxy-Objekt zurück, das Methodenaufrufe an eine Eltern- oder Geschwisterklasse des Typs delegiert. Dies ist nützlich für den Zugriff auf geerbte Methoden, die in einer Klasse überschrieben wurden. Die Suchreihenfolge ist dieselbe wie bei getattr(), mit der Ausnahme, dass der Typ selbst übersprungen wird.

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()

Answer 3

ImmediateParentClass.frotz(self)

ist völlig in Ordnung, egal ob die unmittelbare übergeordnete Klasse, die frotz selbst oder geerbt. super ist nur für die ordnungsgemäße Unterstützung von mehrere Vererbung (und dann funktioniert es nur, wenn jede Klasse es richtig verwendet). Generell, AnyClass.whatever wird nachschlagen whatever in AnyClass Vorfahren, wenn AnyClass nicht definiert/überschreibt, und das gilt für "Child class calling parent's method" genauso wie für jedes andere Vorkommen!

Answer 4

Python 3 hat eine andere und einfachere Syntax für den Aufruf der übergeordneten Methode.

Si Foo Klasse erbt von Bar , dann von Bar.__init__ kann aufgerufen werden von Foo über super().__init__() :

class Foo(Bar):

    def __init__(self, *args, **kwargs):
        # invoke Bar.__init__
        super().__init__(*args, **kwargs)

Answer 5

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