Die Methode einer Elternklasse aus der Kinderklasse aufrufen?

Wenn Sie eine einfache Objekthierarchie in Python erstellen, möchte ich Methoden der übergeordneten Klasse aus einer abgeleiteten Klasse aufrufen können. In Perl und Java gibt es ein Schlüsselwort für this ( super). In Perl könnte ich Folgendes 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 vom untergeordneten benennen muss. Im obigen Beispiel müsste ich so etwas tun 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 Informationsschmerz.

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

Ja, aber nur mit neuen Klassen . Verwenden Sie die super()Funktion:

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

Verwenden Sie für Python <3:

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

Python hat auch super :

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

Gibt ein Proxy-Objekt zurück, das Methodenaufrufe an eine übergeordnete oder Geschwisterklasse vom Typ delegiert. Dies ist nützlich, um auf geerbte Methoden zuzugreifen, die in einer Klasse überschrieben wurden. Die Suchreihenfolge ist dieselbe wie die von getattr () verwendete, außer 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()

ImmediateParentClass.frotz(self)

wird in Ordnung sein, ob die unmittelbare übergeordnete Klasse sich frotzselbst definiert oder geerbt hat. superwird nur für die ordnungsgemäße Unterstützung der Mehrfachvererbung benötigt (und funktioniert dann nur, wenn jede Klasse sie ordnungsgemäß verwendet). Im Allgemeinen AnyClass.whateverwird whateverin AnyClassden Vorfahren nachgeschlagen, wenn AnyClasses nicht definiert / überschrieben wird, und dies gilt für "untergeordnete Klasse, die die Methode der Eltern aufruft" wie für jedes andere Vorkommen!

Python 3 hat eine andere und einfachere Syntax zum Aufrufen der übergeordneten Methode.

Wenn die FooKlasse von erbt Bar, Bar.__init__kann from von Foovia aufgerufen werden super().__init__():

class Foo(Bar):

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

In vielen Antworten wurde erklärt, wie eine Methode vom Elternteil aufgerufen wird, die im Kind überschrieben wurde.

jedoch

"Wie ruft man die Methode einer Elternklasse von der Kindklasse auf?"

könnte auch nur bedeuten:

"Wie nennt man geerbte Methoden?"

Sie können Methoden aufrufen, die von einer übergeordneten Klasse geerbt wurden, als wären sie Methoden der untergeordneten Klasse, sofern sie nicht überschrieben wurden.

zB 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 mag ziemlich offensichtlich sein, aber ich glaube, ohne darauf hinzuweisen, können die Leute diesen Thread mit dem Eindruck verlassen, dass man durch lächerliche Reifen springen muss, um auf geerbte Methoden in Python zuzugreifen. Zumal diese Frage bei der Suche nach "Zugriff auf die Methode einer übergeordneten Klasse in Python" einen hohen Stellenwert hat und das OP aus der Perspektive einer neuen Python-Person geschrieben wurde.

Ich fand: https://docs.python.org/3/tutorial/classes.html#inheritance hilfreich, um zu verstehen, wie Sie auf geerbte Methoden zugreifen.

Hier ist ein Beispiel für die Verwendung von 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

Es gibt auch ein super () in Python. Es ist ein bisschen wackelig, wegen Pythons Klassen im alten und neuen Stil, wird aber ziemlich häufig verwendet, z. B. in Konstruktoren:

class Foo(Bar):
    def __init__(self):
        super(Foo, self).__init__()
        self.baz = 5

Ich würde empfehlen, so CLASS.__bases__ etwas zu verwenden

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

Wenn Sie nicht wissen, wie viele Argumente Sie möglicherweise erhalten, und diese auch an das Kind weitergeben möchten:

class Foo(bar)
    def baz(self, arg, *args, **kwargs):
        # ... Do your thing
        return super(Foo, self).baz(arg, *args, **kwargs)

(Von: Python - Sauberste Methode zum Überschreiben von __init__, wobei nach dem Aufruf von super () ein optionales kwarg verwendet werden muss? )

Es gibt auch ein super () in Python.

Beispiel dafür, wie eine Superklassenmethode von einer Unterklassenmethode aufgerufen wird

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 ähnelt dem oben erläuterten. Es gibt jedoch einen Unterschied, an den super keine Argumente übergeben werden. Dieser obige Code ist in der Python 3.4-Version ausführbar.

In diesem Beispiel cafec_paramhandelt es sich um eine Basisklasse (übergeordnete Klasse) und abceine untergeordnete Klasse. abcruft die AWCMethode in der Basisklasse auf.

class cafec_param:

    def __init__(self,precip,pe,awc,nmonths):

        self.precip = precip
        self.pe = pe
        self.awc = awc
        self.nmonths = nmonths

    def AWC(self):

        if self.awc<254:
            Ss = self.awc
            Su = 0
            self.Ss=Ss
        else:
            Ss = 254; Su = self.awc-254
            self.Ss=Ss + Su   
        AWC = Ss + Su
        return self.Ss


    def test(self):
        return self.Ss
        #return self.Ss*4

class abc(cafec_param):
    def rr(self):
        return self.AWC()


ee=cafec_param('re',34,56,2)
dd=abc('re',34,56,2)
print(dd.rr())
print(ee.AWC())
print(ee.test())

Ausgabe

56

56

56

In Python 2 hatte ich mit super () nicht viel Glück. Ich habe die Antwort von jimifiki in diesem SO-Thread verwendet , um auf eine übergeordnete Methode in Python zu verweisen.. Dann habe ich meine eigene kleine Wendung hinzugefügt, die meiner Meinung nach eine Verbesserung der Benutzerfreundlichkeit darstellt (insbesondere, wenn Sie lange Klassennamen haben).

Definieren Sie die Basisklasse in einem Modul:

 # myA.py

class A():     
    def foo( self ):
        print "foo"

Importieren Sie dann die Klasse in ein anderes Modul as parent:

# myB.py

from myA import A as parent

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

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

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

Dies ist eine abstraktere Methode:

super(self.__class__,self).baz(arg)