Gọi phương thức của lớp cha từ lớp con?

Khi tạo một hệ thống phân cấp đối tượng đơn giản trong Python, tôi muốn có thể gọi các phương thức của lớp cha từ một lớp dẫn xuất. Trong Perl và Java, có một từ khóa cho cái này ( super). Ở Perl, tôi có thể làm điều này:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

Trong Python, có vẻ như tôi phải đặt tên lớp cha rõ ràng từ đứa trẻ. Trong ví dụ trên, tôi phải làm một cái gì đó như Foo::frotz().

Điều này có vẻ không đúng vì hành vi này khiến cho việc phân cấp sâu trở nên khó khăn. Nếu trẻ em cần biết lớp nào định nghĩa một phương thức kế thừa, thì tất cả các loại đau thông tin được tạo ra.

Đây có phải là một giới hạn thực sự trong python, một khoảng cách trong sự hiểu biết của tôi hoặc cả hai?

Có, nhưng chỉ với các lớp học kiểu mới . Sử dụng super()chức năng:

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

Đối với trăn <3, sử dụng:

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

Python cũng có siêu :

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

Trả về một đối tượng proxy ủy nhiệm các cuộc gọi phương thức cho một kiểu cha mẹ hoặc anh chị em của kiểu. Điều này rất hữu ích để truy cập các phương thức được kế thừa đã bị ghi đè trong một lớp. Thứ tự tìm kiếm giống như thứ tự được sử dụng bởi getattr () ngoại trừ loại chính nó bị bỏ qua.

Thí dụ:

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)

sẽ ổn thôi, cho dù lớp cha ngay lập tức frotztự xác định hay kế thừa nó. superchỉ cần cho sự hỗ trợ thích hợp của nhiều kế thừa (và sau đó nó chỉ hoạt động nếu mọi lớp sử dụng đúng cách). Nói chung, AnyClass.whateversẽ tìm kiếm whatevertrong AnyClasstổ tiên nếu AnyClasskhông định nghĩa / ghi đè lên nó và điều này đúng với "phương thức gọi lớp của cha mẹ" như bất kỳ trường hợp nào khác!

Python 3 có một cú pháp khác nhau và đơn giản hơn để gọi phương thức cha.

Nếu Foolớp kế thừa từ Bar, thì từ Bar.__init__có thể được gọi từ Foothông qua super().__init__():

class Foo(Bar):

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

Nhiều câu trả lời đã giải thích làm thế nào để gọi một phương thức từ cha mẹ đã bị ghi đè ở trẻ.

Tuy nhiên

"làm thế nào để bạn gọi phương thức của lớp cha từ lớp con?"

cũng có thể có nghĩa là:

"làm thế nào để bạn gọi các phương thức kế thừa?"

Bạn có thể gọi các phương thức được kế thừa từ một lớp cha giống như chúng là các phương thức của lớp con, miễn là chúng không bị ghi đè.

ví dụ trong trăn 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"

vâng, điều này có thể khá rõ ràng, nhưng tôi cảm thấy rằng nếu không chỉ ra điều này, mọi người có thể rời khỏi chủ đề này với ấn tượng bạn phải nhảy qua những cái vòng lố bịch chỉ để truy cập các phương thức được kế thừa trong python. Đặc biệt là câu hỏi này có tỷ lệ cao trong các tìm kiếm về "cách truy cập phương thức của lớp cha mẹ trong Python" và OP được viết từ quan điểm của một người mới biết về python.

Tôi đã tìm thấy: https://docs.python.org/3/tutorial/groupes.html#inherribution sẽ hữu ích trong việc hiểu cách bạn truy cập các phương thức được kế thừa.

Dưới đây là một ví dụ về việc sử dụng 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

Cũng có một siêu () trong Python. Đó là một chút rắc rối, bởi vì các lớp kiểu cũ và kiểu mới của Python, nhưng được sử dụng khá phổ biến, ví dụ như trong các hàm tạo:

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

Tôi khuyên bạn nên sử dụng CLASS.__bases__ một cái gì đó như thế này

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

Nếu bạn không biết bạn có thể nhận được bao nhiêu cuộc tranh luận và cũng muốn truyền tất cả chúng cho trẻ:

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

(Từ: Python - Cách sạch nhất để ghi đè __init__ trong đó một kwarg tùy chọn phải được sử dụng sau lệnh gọi super ()? )

Có một siêu () trong python cũng.

Ví dụ về cách một phương thức siêu lớp được gọi từ một phương thức lớp phụ

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

Ví dụ này tương tự như đã giải thích ở trên. Tuy nhiên, có một điểm khác biệt là siêu không có bất kỳ đối số nào được truyền cho nó. Đoạn mã trên có thể được thực thi trong phiên bản python 3.4.

Trong ví dụ cafec_paramnày là lớp cơ sở (lớp cha) và abclà lớp con. abcgọi AWCphương thức trong lớp cơ sở.

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

Đầu ra

56

56

56

Trong Python 2, tôi đã không gặp nhiều may mắn với super (). Tôi đã sử dụng câu trả lời từ jimifiki trên luồng SO này làm thế nào để tham khảo một phương thức cha trong python? . Sau đó, tôi đã thêm thắt nhỏ của riêng mình vào nó, mà tôi nghĩ là một sự cải thiện về khả năng sử dụng (Đặc biệt là nếu bạn có tên lớp dài).

Xác định lớp cơ sở trong một mô-đun:

 # myA.py

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

Sau đó nhập lớp vào các mô-đun khác 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()

Đây là một phương pháp trừu tượng hơn:

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