Chamar o método de uma classe pai da classe filho?

Ao criar uma hierarquia de objetos simples em Python, eu gostaria de poder invocar métodos da classe pai de uma classe derivada. No Perl e Java, há uma palavra-chave para this ( super). No Perl, eu devo fazer isso:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

Em Python, parece que eu tenho que nomear explicitamente a classe pai do filho. No exemplo acima, eu teria que fazer algo parecido Foo::frotz().

Isso não parece certo, pois esse comportamento dificulta a criação de hierarquias profundas. Se as crianças precisarem saber que classe definiu um método herdado, todos os tipos de problemas de informação serão criados.

Isso é uma limitação real em python, uma lacuna no meu entendimento ou em ambos?

Sim, mas apenas com classes de novo estilo . Use a super()função:

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)

O Python também tem super :

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

Retorne um objeto proxy que delega chamadas de método a uma classe pai ou irmã do tipo. Isso é útil para acessar métodos herdados que foram substituídos em uma classe. A ordem de pesquisa é igual à usada por getattr (), exceto que o próprio tipo é ignorado.

Exemplo:

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)

ficará bem, se a classe pai imediata frotzse definiu ou a herdou. superé necessário apenas para o suporte adequado à herança múltipla (e funciona apenas se todas as classes o usarem corretamente). Em geral, ele AnyClass.whateverirá procurar whatevernos AnyClassancestrais se AnyClassnão o definir / substituir, e isso vale para "classe filho chamando o método dos pais" como para qualquer outra ocorrência!

O Python 3 possui uma sintaxe diferente e mais simples para chamar o método pai.

Se a Fooclasse herda de Bar, então from Bar.__init__pode ser invocado de Foovia super().__init__():

class Foo(Bar):

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

Muitas respostas explicaram como chamar um método do pai que foi substituído no filho.

Contudo

"como você chama o método de uma classe pai da classe filho?"

também pode significar apenas:

"como você chama métodos herdados?"

Você pode chamar métodos herdados de uma classe pai, como se fossem métodos da classe filho, desde que não tenham sido substituídos.

por exemplo, em 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"

Sim, isso pode ser bastante óbvio, mas eu sinto que, sem apontar isso, as pessoas podem deixar esse segmento com a impressão de que você precisa pular coisas ridículas apenas para acessar métodos herdados em python. Especialmente porque essa pergunta é altamente avaliada em pesquisas sobre "como acessar o método de uma classe pai em Python", e o OP é escrito da perspectiva de alguém novo no python.

Eu achei: https://docs.python.org/3/tutorial/classes.html#inheritance útil para entender como você acessa métodos herdados.

Aqui está um exemplo do 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

Também existe um super () em Python. É um pouco instável, por causa das classes de estilo antigo e novo do Python, mas é bastante comum, por exemplo, nos construtores:

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

Eu recomendaria usar CLASS.__bases__ algo assim

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

Se você não sabe quantos argumentos você pode obter e deseja transmiti-los para a criança também:

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

(From: Python - Maneira mais limpa de substituir __init__ onde um kwarg opcional deve ser usado após a chamada super ()? )

Também existe um super () em python.

Exemplo de como um método de superclasse é chamado de um método de subclasse

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 exemplo é semelhante ao explicado acima.No entanto, há uma diferença que super não possui argumentos passados ​​para ele.Este código acima é executável na versão python 3.4.

Neste exemplo cafec_paramé uma classe base (classe pai) e abcé uma classe filho. abcchama o AWCmétodo na classe 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())

Resultado

56

56

56

No Python 2, não tive muita sorte com o super (). Eu usei a resposta do jimifiki neste tópico SO, como se referir a um método pai em python? . Em seguida, adicionei meu toque pessoal, que acho que é uma melhoria na usabilidade (especialmente se você tiver nomes de classe longos).

Defina a classe base em um módulo:

 # myA.py

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

Em seguida, importe a classe para outros 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 é um método mais abstrato:

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