如何在Python中从子类调用父类的方法?

问题描述 投票:0回答:16

在Python中创建简单的对象层次结构时,我希望能够从派生类调用父类的方法。在 Perl 和 Java 中,有一个关键字(

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的实际限制,还是我理解上的差距,或者两者兼而有之?

python class oop object inheritance
16个回答
1027
投票

使用

super()
功能:

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

对于 Python < 3, you must explicitly opt in to using 新式类并使用:

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

167
投票

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

91
投票
ImmediateParentClass.frotz(self)
无论直接父类定义

frotz

 本身还是继承它,
都会很好。仅需要
super
才能正确支持 multiple 继承(只有每个类都正确使用它才有效)。一般来说,如果
AnyClass.whatever
没有定义/覆盖它,那么
whatever
将在
AnyClass
的祖先中查找
AnyClass
,这对于“子类调用父类的方法”以及任何其他情况都适用!


89
投票

Python 3 有一个不同且更简单的调用父方法的语法。

如果

Foo
类继承自
Bar
,那么可以通过
Bar.__init__
Foo
调用
super().__init__()

class Foo(Bar):

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

79
投票

许多答案都解释了如何从父级调用已在子级中重写的方法。

但是

“如何从子类调用父类的方法?”

也可能意味着:

“如何调用继承的方法?”

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

例如在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 对于理解如何访问继承的方法很有用。


32
投票

这是使用 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

14
投票

Python 中也有 super() 。由于 Python 的旧式和新式类,它有点奇怪,但非常常用,例如在构造函数中:

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

9
投票

我建议使用

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

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?


5
投票

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 版本中是可执行的。


5
投票

在此示例中,

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

3
投票

在 Python 2 中,我对 super() 的使用不太好。我使用了来自的答案 jimifiki 在此 SO 线程上如何在 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()'

2
投票
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()

1
投票

如果要调用任何类的方法,只需在该类的任何实例上调用

Class.method
即可。如果您的继承相对干净,这也适用于子类的实例:

class Foo:
    def __init__(self, var):
        self.var = var
    
    def baz(self):
        return self.var

class Bar(Foo):
    pass

bar = Bar(1)
assert Foo.baz(bar) == 1

-2
投票
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()

-26
投票

这是一个更抽象的方法:

super(self.__class__,self).baz(arg)
© www.soinside.com 2019 - 2024. All rights reserved.