从Python中的子类调用父类的方法？

Question

在Python中创建一个简单的对象层次结构时,我希望能够从派生类中调用父类的方法.在Perl和Java中,有一个关键字this(super).在Perl中,我可能会这样做:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

在python中,似乎我必须从子级明确命名父类.在上面的例子中,我必须做类似的事情Foo::frotz().

这似乎不对,因为这种行为使得很难制作深层次结构.如果孩子需要知道哪个类定义了一个继承的方法,那么就会产生各种各样的信息痛苦.

这是python中的实际限制,是我理解中的差距还是两者兼而有之？

Answer 1

是的,但只适用于新式课程.使用super()功能:

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

Answer 2

Python也有超级:

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

Answer 3

ImmediateParentClass.frotz(self)

无论是直接的父类定义frotz自己还是继承它,都会很好. super仅需要对多重继承的适当支持(然后它只适用于每个类正确使用它).一般情况下,AnyClass.whatever是要查找whatever在AnyClass的祖先,如果AnyClass没有定义/覆盖它,而这个'呼吁父母的方法子类’作为任何其它情况适用于真!

Answer 4

Python 3具有用于调用父方法的不同且更简单的语法.

如果Foo类继承自Bar,则Bar.__init__可以从Foovia 调用from super().__init__():

class Foo(Bar):

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

Answer 5

许多答案已经解释了如何从已在子项中重写的父项调用方法.

然而

"你如何从子类中调用父类的方法？"

也可能只是意味着:

"你怎么称为继承方法？"

您可以调用从父类继承的方法,就像它们是子类的方法一样,只要它们没有被覆盖.

例如在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 有助于理解如何访问继承的方法.

Answer 6

以下是使用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

Answer 7

Python中也有一个super().由于Python的旧式和新式类,它有点不稳定,但在构造函数中非常常用:

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

Answer 8

我建议使用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()

Answer 9

如果你不知道你可能得到多少个参数,并且想要将它们全部传递给孩子:

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

(来自:Python - 覆盖__init__的最干净的方法,在super()调用之后必须使用可选的kwarg？)

Answer 10

python 中也有一个 super() 。

如何从子类方法调用超类方法的示例

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

这个例子类似于上面解释的那个。但是有一个区别是 super 没有任何参数传递给它。上面的代码在 python 3.4 版本中是可执行的。

Answer 11

在这个例子中cafec_param是一个基类（父类）并且abc是一个子类。abc调用AWC基类中的方法。

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

输出

56

56

56