Appelez la méthode d'une classe parent à partir de la classe enfant?

Lors de la création d'une hiérarchie d'objets simple en Python, j'aimerais pouvoir invoquer des méthodes de la classe parente à partir d'une classe dérivée. En Perl et Java, il existe un mot-clé pour cela ( super). En Perl, je pourrais faire ceci:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

En Python, il semble que je doive nommer explicitement la classe parente de l'enfant. Dans l'exemple ci-dessus, je devrais faire quelque chose comme Foo::frotz().

Cela ne semble pas correct car ce comportement rend difficile la création de hiérarchies profondes. Si les enfants ont besoin de savoir quelle classe a défini une méthode héritée, alors toutes sortes d'informations sont créées.

Est-ce une limitation réelle en python, une lacune dans ma compréhension ou les deux?

Oui, mais uniquement avec des classes de nouveau style . Utilisez la super()fonction:

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

Pour python <3, utilisez:

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

Python a également des super :

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

Renvoie un objet proxy qui délègue les appels de méthode à une classe parent ou frère de type. Ceci est utile pour accéder aux méthodes héritées qui ont été remplacées dans une classe. L'ordre de recherche est le même que celui utilisé par getattr () sauf que le type lui-même est ignoré.

Exemple:

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)

sera très bien, que la classe parent immédiate se soit définie frotzou en ait hérité. supern'est nécessaire que pour la prise en charge appropriée de l' héritage multiple (et cela ne fonctionne que si chaque classe l'utilise correctement). En général, AnyClass.whateverva chercher whateverdans AnyClassles ancêtres de s'il AnyClassne le définit pas / ne le remplace pas, et cela vaut pour la "classe enfant appelant la méthode du parent" comme pour toute autre occurrence!

Python 3 a une syntaxe différente et plus simple pour appeler la méthode parent.

Si la Fooclasse hérite de Bar, alors from Bar.__init__peut être invoqué depuis Foovia super().__init__():

class Foo(Bar):

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

De nombreuses réponses ont expliqué comment appeler une méthode du parent qui a été remplacée par l'enfant.

toutefois

"Comment appelez-vous la méthode d'une classe parent à partir d'une classe enfant?"

pourrait aussi signifier simplement:

"comment appelez-vous les méthodes héritées?"

Vous pouvez appeler des méthodes héritées d'une classe parent comme si elles étaient des méthodes de la classe enfant, tant qu'elles n'ont pas été écrasées.

par exemple en 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"

oui, cela peut être assez évident, mais je pense que sans le souligner, les gens peuvent laisser ce fil avec l'impression que vous devez sauter à travers des cerceaux ridicules juste pour accéder aux méthodes héritées en python. D'autant plus que cette question est très appréciée dans les recherches de "comment accéder à la méthode d'une classe parente en Python", et que l'OP est écrit du point de vue de quelqu'un de nouveau en python.

J'ai trouvé: https://docs.python.org/3/tutorial/classes.html#inheritance utile pour comprendre comment vous accédez aux méthodes héritées.

Voici un exemple d'utilisation de 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

Il y a aussi un super () en Python. C'est un peu loufoque, à cause des classes de style ancien et nouveau de Python, mais il est assez couramment utilisé par exemple dans les constructeurs:

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

Je recommanderais d'utiliser CLASS.__bases__ quelque chose comme ça

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

Si vous ne savez pas combien d'arguments vous pourriez obtenir et que vous souhaitez également les transmettre à l'enfant:

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

(De: Python - La façon la plus propre de remplacer __init__ où un kwarg optionnel doit être utilisé après l'appel de super ()? )

Il y a aussi un super () en python.

Exemple sur la façon dont une méthode de super classe est appelée à partir d'une méthode de sous-classe

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

Cet exemple est similaire à celui expliqué ci-dessus.Cependant, il y a une différence que super n'a pas d'arguments passés.Ce code ci-dessus est exécutable dans la version python 3.4.

Dans cet exemple, il cafec_params'agit d'une classe de base (classe parent) et d' abcune classe enfant. abcappelle la AWCméthode dans la classe de base.

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

Production

56

56

56

En Python 2, je n'ai pas eu beaucoup de chance avec super (). J'ai utilisé la réponse de jimifiki sur ce fil SO comment faire référence à une méthode parent en python?. Ensuite, j'ai ajouté ma propre petite touche, ce qui, je pense, est une amélioration de la convivialité (surtout si vous avez des noms de classe longs).

Définissez la classe de base dans un module:

 # myA.py

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

Importez ensuite la classe dans un autre module 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()

Il s'agit d'une méthode plus abstraite:

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