¿Llamar al método de una clase principal desde la clase secundaria?

Al crear una jerarquía de objetos simple en Python, me gustaría poder invocar métodos de la clase primaria desde una clase derivada. En Perl y Java, hay una palabra clave para this ( super). En Perl, podría hacer esto:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

En Python, parece que tengo que nombrar la clase padre explícitamente desde el niño. En el ejemplo anterior, tendría que hacer algo como Foo::frotz().

Esto no parece correcto ya que este comportamiento dificulta la creación de jerarquías profundas. Si los niños necesitan saber qué clase definió un método heredado, entonces se crea todo tipo de dolor de información.

¿Es esta una limitación real en Python, un vacío en mi comprensión o ambos?

Sí, pero solo con clases de estilo nuevo . Usa la super()función:

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

Para python <3, use:

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

Python también tiene super :

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

Devuelve un objeto proxy que delega llamadas de método a una clase de tipo padre o hermano. Esto es útil para acceder a métodos heredados que se han anulado en una clase. El orden de búsqueda es el mismo que el utilizado por getattr (), excepto que se omite el tipo en sí.

Ejemplo:

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)

estará bien, ya sea que la clase primaria inmediata se haya definido frotzo heredado. supersolo es necesario para el soporte adecuado de la herencia múltiple (y luego solo funciona si cada clase lo usa correctamente). En general, AnyClass.whateverbuscará whateveren AnyClasslos antepasados ​​si AnyClassno lo define / anula, ¡y esto es válido para el "método de los padres que llaman a la clase secundaria" como para cualquier otra ocurrencia!

Python 3 tiene una sintaxis diferente y más simple para llamar al método padre.

Si la Fooclase hereda de Bar, entonces Bar.__init__se puede invocar desde a Footravés de super().__init__():

class Foo(Bar):

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

Muchas respuestas han explicado cómo llamar a un método del padre que se ha anulado en el hijo.

sin embargo

"¿Cómo se llama el método de una clase principal desde la clase secundaria?"

También podría significar simplemente:

"¿Cómo se llaman los métodos heredados?"

Puede llamar a los métodos heredados de una clase principal como si fueran métodos de la clase secundaria, siempre que no se hayan sobrescrito.

Por ejemplo, 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"

Sí, esto puede ser bastante obvio, pero creo que sin señalar esto, las personas pueden dejar este hilo con la impresión de que tienes que saltar a través de aros ridículos solo para acceder a métodos heredados en Python. Especialmente porque esta pregunta tiene una alta calificación en las búsquedas de "cómo acceder al método de una clase primaria en Python", y el OP se escribe desde la perspectiva de alguien nuevo en python.

Encontré que: https://docs.python.org/3/tutorial/classes.html#inheritance es útil para comprender cómo accede a los métodos heredados.

Aquí hay un ejemplo del uso 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

También hay un super () en Python. Es un poco raro, debido a las clases de estilo antiguo y nuevo de Python, pero se usa con bastante frecuencia, por ejemplo, en constructores:

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

Yo recomendaría usar CLASS.__bases__ algo como esto

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 no sabe cuántos argumentos puede obtener y desea pasarlos también al niño:

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

(De: Python: ¿la forma más limpia de anular __init__ donde se debe usar un kwarg opcional después de la llamada super ()? )

También hay un super () en python.

Ejemplo de cómo se llama a un método de superclase desde un método de subclase

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

Este ejemplo es similar al explicado anteriormente. Sin embargo, hay una diferencia de que super no tiene ningún argumento pasado. Este código anterior es ejecutable en la versión Python 3.4.

En este ejemplo cafec_parames una clase base (clase primaria) y abces una clase secundaria. abcllama al AWCmétodo en la clase 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())

Salida

56

56

56

En Python 2, no tuve mucha suerte con super (). Utilicé la respuesta de jimifiki en este hilo SO, ¿cómo referirme a un método padre en python? . Luego, le agregué mi propio pequeño giro, lo que creo que es una mejora en la usabilidad (especialmente si tiene nombres de clase largos).

Defina la clase base en un módulo:

 # myA.py

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

Luego importe la clase a otros módulos 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()

Este es un método más abstracto:

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