Wywołać metodę klasy nadrzędnej z klasy podrzędnej?

Podczas tworzenia prostej hierarchii obiektów w Pythonie chciałbym móc wywoływać metody klasy nadrzędnej z klasy pochodnej. W Perlu i Javie istnieje słowo kluczowe dla tego ( super). W Perlu mogę to zrobić:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

W Pythonie wydaje się, że muszę wyraźnie nazwać klasę nadrzędną od dziecka. W powyższym przykładzie musiałbym zrobić coś takiego Foo::frotz().

Nie wydaje się to właściwe, ponieważ takie zachowanie utrudnia tworzenie głębokich hierarchii. Jeśli dzieci muszą wiedzieć, która klasa zdefiniowała odziedziczoną metodę, powstają różnego rodzaju bóle informacyjne.

Czy to rzeczywiste ograniczenie w pythonie, luka w moim rozumieniu, czy jedno i drugie?

Tak, ale tylko z klasami w nowym stylu . Użyj super()funkcji:

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

W przypadku python <3 użyj:

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

Python ma również super :

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

Zwraca obiekt proxy, który deleguje wywołania metod do nadrzędnej lub siostrzanej klasy typu. Jest to przydatne do uzyskiwania dostępu do odziedziczonych metod, które zostały zastąpione w klasie. Kolejność wyszukiwania jest taka sama, jak używana przez getattr (), tyle że sam typ jest pomijany.

Przykład:

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)

będzie dobrze, bez względu na to, czy bezpośrednia klasa nadrzędna zdefiniowała frotzsię, czy odziedziczyła. superjest potrzebny tylko do prawidłowej obsługi wielokrotnego dziedziczenia (a wtedy działa tylko wtedy, gdy każda klasa używa go poprawnie). Ogólnie rzecz biorąc, AnyClass.whateverbędzie patrzeć whateverw AnyClass„s przodków jeśli AnyClassnie definiuje / nadpisać go, a to odnosi się do«klasy dziecięcej wywołanie metody rodzica», jak dla każdego innego wystąpienia!

Python 3 ma inną i prostszą składnię do wywoływania metody nadrzędnej.

Jeśli Fooklasa dziedziczy po Bar, to Bar.__init__można wywołać z from Fooza pośrednictwem super().__init__():

class Foo(Bar):

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

Wiele odpowiedzi wyjaśniło, jak wywołać metodę nadrzędną, która została zastąpiona przez dziecko.

jednak

„jak wywołać metodę klasy nadrzędnej z klasy podrzędnej?”

może również oznaczać:

„jak nazywacie metody dziedziczone?”

Możesz wywoływać metody dziedziczone z klasy nadrzędnej tak, jakby były metodami klasy podrzędnej, o ile nie zostały zastąpione.

np. w 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"

tak, może to być dość oczywiste, ale czuję, że bez wskazania tego, ludzie mogą zostawić ten wątek z wrażeniem, że musisz skakać przez absurdalne obręcze tylko po to, aby uzyskać dostęp do odziedziczonych metod w pythonie. Zwłaszcza, że ​​to pytanie jest bardzo cenne w wyszukiwaniu „jak uzyskać dostęp do metody klasy nadrzędnej w Pythonie”, a OP jest napisane z perspektywy kogoś nowego w Pythonie.

Uważam, że: https://docs.python.org/3/tutorial/classes.html#inheritance jest przydatny w zrozumieniu, w jaki sposób uzyskujesz dostęp do odziedziczonych metod.

Oto przykład użycia 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

W Pythonie jest też super (). Jest nieco nieporadny z powodu klas starego i nowego stylu Pythona, ale jest dość powszechnie stosowany np. W konstruktorach:

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

Poleciłbym użycie CLASS.__bases__ czegoś takiego

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

Jeśli nie wiesz, ile argumentów możesz uzyskać, i chcesz przekazać je również dziecku:

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

(Od: Python - Najczystszy sposób na przesłonięcie __init__, gdzie po wywołaniu super () należy użyć opcjonalnego kwarga? )

W pythonie znajduje się również super ().

Przykład wywołania metody superklasy z metody podklasy

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

Ten przykład jest podobny do tego wyjaśnionego powyżej, jednak istnieje jedna różnica polegająca na tym, że super nie ma żadnych argumentów. Powyższy kod jest wykonywalny w wersji Python 3.4.

W tym przykładzie cafec_paramjest to klasa podstawowa (klasa nadrzędna) i abcklasa podrzędna. abcwywołuje AWCmetodę w klasie bazowej.

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

Wynik

56

56

56

W Pythonie 2 nie miałem dużo szczęścia z super (). Użyłem odpowiedzi z jimifiki w tym wątku SO, jak odwoływać się do metody nadrzędnej w pythonie? . Następnie dodałem do tego swój własny mały zwrot, który moim zdaniem poprawia użyteczność (szczególnie jeśli masz długie nazwy klas).

Zdefiniuj klasę podstawową w jednym module:

 # myA.py

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

Następnie zaimportuj klasę do innych modułów 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()

To jest bardziej abstrakcyjna metoda:

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