Panggil metode kelas induk dari kelas anak?

Saat membuat hierarki objek sederhana dalam Python, saya ingin dapat memanggil metode dari kelas induk dari kelas turunan. Di Perl dan Java, ada kata kunci untuk ini ( super). Di Perl, saya mungkin melakukan ini:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

Dalam Python, tampaknya saya harus memberi nama kelas induk secara eksplisit dari anak. Pada contoh di atas, saya harus melakukan sesuatu seperti Foo::frotz().

Ini sepertinya tidak benar karena perilaku ini menyulitkan untuk membuat hierarki yang mendalam. Jika anak-anak perlu tahu kelas apa yang mendefinisikan metode yang diwariskan, maka semua jenis rasa sakit informasi dibuat.

Apakah ini keterbatasan sebenarnya dalam python, celah dalam pemahaman saya atau keduanya?

Ya, tetapi hanya dengan kelas gaya baru . Gunakan super()fungsinya:

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

Untuk python <3, gunakan:

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

Python juga memiliki super juga:

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

Mengembalikan objek proxy yang mendelegasikan panggilan metode ke kelas tipe induk atau saudara kandung. Ini berguna untuk mengakses metode yang diwariskan yang telah ditimpa dalam kelas. Urutan pencarian sama dengan yang digunakan oleh getattr () kecuali bahwa tipe itu sendiri dilewati.

Contoh:

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)

akan baik-baik saja, apakah kelas induk langsung didefinisikan frotzsendiri atau diwarisi. superhanya diperlukan untuk dukungan yang tepat dari multiple inheritance (dan kemudian hanya berfungsi jika setiap kelas menggunakannya dengan benar). Secara umum, AnyClass.whateverakan mencari whateverdi AnyClassleluhur 's jika AnyClasstidak mendefinisikan / menimpa itu, dan ini berlaku untuk 'kelas anak memanggil metode orangtua' seperti untuk terjadinya lainnya!

Python 3 memiliki sintaks yang berbeda dan lebih sederhana untuk memanggil metode induk.

Jika Fookelas mewarisi dari Bar, maka dari Bar.__init__dapat dipanggil Foomelalui super().__init__():

class Foo(Bar):

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

Banyak jawaban telah menjelaskan cara memanggil metode dari orang tua yang telah ditimpa pada anak.

Namun

"Bagaimana kamu memanggil metode kelas induk dari kelas anak?"

bisa juga berarti:

"Bagaimana Anda memanggil metode yang diwariskan?"

Anda dapat memanggil metode yang diwarisi dari kelas induk sama seperti jika mereka adalah metode kelas anak, asalkan mereka belum ditimpa.

misalnya dalam 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"

ya, ini mungkin cukup jelas, tetapi saya merasa bahwa tanpa menunjukkan ini orang dapat meninggalkan utas ini dengan kesan Anda harus melompat melalui lingkaran konyol hanya untuk mengakses metode yang diwariskan dalam python. Terutama karena pertanyaan ini sangat dicari dalam "cara mengakses metode kelas induk dengan Python", dan OP ditulis dari sudut pandang seseorang yang baru mengenal python.

Saya menemukan: https://docs.python.org/3/tutorial/classes.html#inheritance berguna dalam memahami bagaimana Anda mengakses metode yang diwariskan.

Berikut adalah contoh penggunaan 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

Ada super () di Python juga. Ini agak miring, karena kelas gaya lama dan baru Python, tetapi cukup umum digunakan misalnya dalam konstruktor:

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

Saya akan merekomendasikan menggunakan CLASS.__bases__ sesuatu seperti ini

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

Jika Anda tidak tahu berapa banyak argumen yang mungkin Anda dapatkan, dan ingin menyampaikan semuanya kepada anak juga:

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

(Dari: Python - Cara terbersih untuk mengganti __init__ di mana kwarg opsional harus digunakan setelah panggilan super ()? )

Ada super () di python juga.

Contoh untuk bagaimana metode kelas super dipanggil dari metode kelas bawah

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

Contoh ini mirip dengan yang dijelaskan di atas. Namun ada satu perbedaan yang super tidak memiliki argumen yang dilewatinya. Kode di atas ini dapat dieksekusi dalam versi python 3.4.

Dalam contoh ini cafec_paramadalah kelas dasar (kelas induk) dan abcmerupakan kelas anak. abcmemanggil AWCmetode di kelas dasar.

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

Keluaran

56

56

56

Dalam Python 2, saya tidak memiliki banyak keberuntungan dengan super (). Saya menggunakan jawaban dari jimifiki pada utas SO ini bagaimana merujuk ke metode induk dengan python?. Kemudian, saya menambahkan sedikit twist saya sendiri untuk itu, yang saya pikir merupakan peningkatan dalam kegunaan (Terutama jika Anda memiliki nama kelas yang panjang).

Tentukan kelas dasar dalam satu modul:

 # myA.py

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

Kemudian impor kelas ke modul lain 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()

Ini adalah metode yang lebih abstrak:

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