Bir üst sınıfın yöntemini alt sınıftan mı çağırıyorsunuz?

Python'da basit bir nesne hiyerarşisi oluştururken, türetilmiş bir sınıftan üst sınıf yöntemlerini çağırabilmek istiyorum. Perl ve Java'da bunun için bir anahtar kelime vardır ( super). Perl'de bunu yapabilirim:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

Python, alt sınıf açıkça alt sınıf adlandırmak zorunda gibi görünüyor. Yukarıdaki örnekte, böyle bir şey yapmam gerekirdi Foo::frotz().

Bu doğru görünmüyor çünkü bu davranış derin hiyerarşiler oluşturmayı zorlaştırıyor. Çocukların hangi sınıfın kalıtsal bir yöntemi tanımladığını bilmesi gerekiyorsa, her türlü bilgi ağrısı yaratılır.

Bu, python'da gerçek bir sınırlama mı, anlayışımdaki bir boşluk mu yoksa her ikisi de mi?

Evet, ama sadece yeni stil sınıflarıyla . super()İşlevi kullanın :

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

<3 python için şunları kullanın:

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

Python da süper var :

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

Bir üst veya kardeş sınıf sınıfına yöntem çağrılarını devreten bir proxy nesnesi döndürün. Bu, bir sınıfta geçersiz kılınmış kalıtsal yöntemlere erişmek için kullanışlıdır. Arama sırası, türün kendisinin atlanması dışında getattr () tarafından kullanılanla aynıdır.

Misal:

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)

ana sınıfın frotzkendisini tanımlaması veya miras alması iyi olur. superyalnızca çoklu kalıtımın doğru şekilde desteklenmesi için gereklidir (ve daha sonra yalnızca her sınıf bunu doğru kullanıyorsa çalışır). Genel olarak, AnyClass.whateverbakmak için gidiyor whateveriçinde AnyClasseğer insan atalarının AnyClass/ tanımlamak bunu geçersiz kılmaz ve bu da başka bir oluşum için olduğu gibi 'ebeveyn yöntemini çağırarak çocuk sınıfına' için de geçerlidir!

Python 3 , ana yöntemi çağırmak için farklı ve daha basit bir sözdizimine sahiptir.

Eğer Foosınıfını miras dan Barsonra gelen Bar.__init__çağrılabilir Fooyoluyla super().__init__():

class Foo(Bar):

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

Birçok cevap, çocukta geçersiz kılınan ebeveynten bir yöntemin nasıl çağrılacağını açıkladı.

ancak

"Bir üst sınıfın yöntemini alt sınıftan nasıl çağırıyorsunuz?"

sadece şu anlama gelebilir:

"Kalıtsal yöntemler nasıl adlandırılır?"

Üst sınıftan miras alınan yöntemleri, tıpkı üzerine yazılmadığı sürece, alt sınıfın yöntemleriymiş gibi çağırabilirsiniz.

örneğin python 3'te:

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"

Evet, bu oldukça açık olabilir, ama bunu işaret etmeden insanların bu ipliği python'da kalıtsal yöntemlere erişmek için saçma çemberlerden atlamak zorunda olduğu izlenimiyle bırakabileceğini hissediyorum. Özellikle bu soru, "Python'da bir ana sınıfın yöntemine nasıl erişileceği" aramalarında yüksek oranda derecelendirilir ve OP, python'a yeni birinin bakış açısından yazılır.

Kalıtımsal yöntemlere nasıl eriştiğinizi anlamada yararlı olduğunu https://docs.python.org/3/tutorial/classes.html#inheritance buldum .

Super () kullanımına bir örnek :

#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

Python'da da bir süper () var. Python'un eski ve yeni stil sınıfları nedeniyle biraz sakat, ancak örneğin inşaatçılarda oldukça yaygın olarak kullanılıyor:

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

CLASS.__bases__ Böyle bir şey kullanmanızı tavsiye ederim

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

Kaç argüman alabileceğinizi bilmiyorsanız ve bunları çocuğa da iletmek istiyorsanız:

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

(Kimden: Python - super () çağrısından sonra isteğe bağlı bir kwarg kullanılması gereken __init__'yi geçersiz kılmanın en temiz yolu? )

Python'da da bir süper () vardır.

Bir alt sınıf yönteminden bir süper sınıf yönteminin nasıl çağrıldığına örnek

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

Bu örnek, yukarıda açıklanan örneğe benzer, ancak süper değişkenin kendisine iletilen herhangi bir argümanı olmayan bir fark vardır. Yukarıdaki kod python 3.4 sürümünde yürütülebilir.

Bu örnekte cafec_parambir temel sınıf (üst sınıf) ve abcbir alt sınıftır. temel sınıftaki yöntemi abcçağırır 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())

Çıktı

56

56

56

Python 2'de super () ile pek şansım yoktu. Python bir üst yönteme başvurmak nasıl bu SO iş parçacığında jimifiki gelen cevap kullanılır ?. Sonra, kendi küçük bükümümü ekledim, bu da kullanılabilirlikte bir gelişme olduğunu düşünüyorum (Özellikle uzun sınıf isimleriniz varsa).

Temel sınıfı bir modülde tanımlayın:

 # myA.py

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

Ardından sınıfı başka bir modüle alın 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()

Bu daha soyut bir yöntemdir:

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