Использовать & ldquo; функции в классе A & rdquo; в __init__ класса B после наследования [дубликат]

Python 3 имеет другой и более простой синтаксис для вызова родительского метода. Если класс Foo наследуется от Bar, то из Bar.__init__ можно вызвать из Foo с помощью super().__init__():

class Foo(Bar):
    def __init__(self):
        super().__init__()

Многие ответы объяснили, как вызвать метод из родителя, который был переопределен в дочернем файле.

Однако

"как вы называете метод родительского класса из дочернего класса? "

также может означать только:

" как вы называете унаследованные методы? "

Вы можете вызывать методы, унаследованные от родительского класса, точно так же, как если бы они были методами дочернего класса, если они не были перезаписаны.

, например. в 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"

да, это может быть довольно очевидным, но я чувствую, что, не указывая на это, люди могут покинуть этот поток с впечатлением, что вам нужно перепрыгнуть через смешные обручи, чтобы получить доступ к унаследованным методам в python. Тем более, что этот вопрос высоко оценивает поиск «как получить доступ к методу родительского класса в Python», а OP написан с точки зрения кого-то нового для python.

Я нашел: https: //docs.python.org/3/tutorial/classes.html#inheritance, чтобы быть полезными для понимания того, как вы получаете доступ к унаследованным методам.

В Python 2 мне не повезло с super (). Я использовал ответ от jimifiki на этом SO thread как ссылаться на родительский метод в python? . Затем я добавил к этому свой собственный небольшой поворот, который, по моему мнению, является улучшением удобства использования (особенно если у вас длинные имена классов).

Определите базовый класс в одном модуле:

 # myA.py

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

Затем импортируйте класс в другие модули as parent:

# myB.py

from myA import A as parent

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

ImmediateParentClass.frotz(self)

будет просто прекрасным, независимо от того, был ли непосредственно установленный родительский класс frotz или унаследовал его. super требуется только для правильной поддержки множественного наследования (и тогда он работает только в том случае, если каждый класс правильно использует его). В общем случае AnyClass.whatever будет искать whatever в предках AnyClass, если AnyClass не определяет / не отменяет его, и это справедливо для «метода родительского класса, вызывающего родительский метод», как и для любого другого случая !

Я бы рекомендовал использовать CLASS.__bases__ что-то вроде этого

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

Существует также супер () в python.

Пример того, как метод суперкласса вызывается из метода подкласса

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

Этот пример аналогичен один из которых описан выше. Однако есть одно отличие: супер не имеет аргументов, переданных ему. Этот выше код является исполняемым в версии python 3.4.

В Python есть супер (). Это немного странно, из-за классов старого и нового стиля Python, но довольно часто используется, например. в конструкторах:

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

Python также имеет super :

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

Возвращает прокси-объект, который делегирует вызовы методов родителям или родственникам класс типа. Это полезно для доступа к унаследованным методам, которые были переопределены в классе. Порядок поиска такой же, как и для getattr (), за исключением того, что сам тип пропускается.

Пример:

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

Это более абстрактный метод:

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

Вот пример использования функции 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