python - पाइथन में बाल वर्ग से अभिभावक वर्ग की विधि को कॉल करें?




inheritance class (8)

पायथन में एक साधारण ऑब्जेक्ट पदानुक्रम बनाते समय, मैं व्युत्पन्न वर्ग से अभिभावक वर्ग के तरीकों का आह्वान करने में सक्षम होना चाहता हूं। पर्ल और जावा में, इस (सुपर) के लिए एक कीवर्ड है। पर्ल में, मैं यह कर सकता हूं:

package Foo;

sub frotz {
    return "Bamf";
}

package Bar;
@ISA = qw(Foo);

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

पायथन में, ऐसा प्रतीत होता है कि मुझे बच्चे से स्पष्ट रूप से मूल वर्ग का नाम देना होगा। उपर्युक्त उदाहरण में, मुझे कुछ ऐसा करना होगा जैसे Foo :: frotz ()।

यह सही प्रतीत नहीं होता है, क्योंकि इस व्यवहार से गहरी पदानुक्रम बनाना मुश्किल हो जाता है। अगर बच्चों को यह जानने की आवश्यकता है कि किस वर्ग ने विरासत विधि को परिभाषित किया है, तो सभी प्रकार के सूचना दर्द पैदा होते हैं।

क्या यह पाइथन में एक वास्तविक सीमा है, मेरी समझ में अंतर या दोनों?


कई उत्तरों ने बताया है कि बच्चे में ओवरराइड किए गए माता-पिता से एक विधि कैसे कॉल करें।

तथापि

"आप बाल वर्ग से अभिभावक वर्ग की विधि कैसे कॉल करते हैं?"

इसका मतलब भी हो सकता है:

"आप विरासत विधियों को कैसे कॉल करते हैं?"

आप अभिभावक वर्ग से विरासत में प्राप्त विधियों को कॉल कर सकते हैं जैसे कि वे बाल वर्ग के तरीके थे, जब तक कि वे अधिलेखित नहीं किए गए थे।

उदाहरण के लिए अजगर 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"

हां, यह काफी स्पष्ट हो सकता है, लेकिन मुझे लगता है कि इस बात को इंगित किए बिना लोग इस धागे को इंप्रेशन के साथ छोड़ सकते हैं, आपको पाइथन में विरासत में प्राप्त विधियों तक पहुंचने के लिए हास्यास्पद हुप्स के माध्यम से कूदना होगा। विशेष रूप से इस प्रश्न के रूप में "पाइथन में अभिभावक वर्ग की विधि को कैसे पहुंचाया जा सकता है" के लिए खोजों में अत्यधिक दर है, और ओपी किसी नए व्यक्ति के परिप्रेक्ष्य से लिखे गए हैं।

मैंने पाया: https://docs.python.org/3/tutorial/classes.html#inheritance समझने में उपयोगी होने के लिए कि आप विरासत विधियों तक कैसे पहुंचते हैं।


पाइथन 3 में पैरेंट विधि को कॉल करने के लिए एक अलग और सरल वाक्यविन्यास है। यदि Foo क्लास Bar से विरासत में मिलता है, तो Bar.__init__ को super().__init__() का उपयोग करके Foo से बुलाया जा सकता है:

class Foo(Bar):
    def __init__(self):
        super().__init__()

पाइथन में भी एक सुपर () है। यह पाइथन की पुरानी और नई शैली के वर्गों की वजह से थोड़ा सा गड़बड़ है, लेकिन इसका उपयोग आमतौर पर किया जाता है जैसे कि रचनाकारों में:

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

पायथन 2 में, मेरे पास सुपर () के साथ बहुत भाग्य नहीं था। मैंने इस एसओ थ्रेड पर जिम्फिकी से जवाब का उपयोग कैसे किया है, जिसमें पाइथन में मूल विधि का संदर्भ कैसे दिया जाए? । फिर, मैंने इसे अपना छोटा मोड़ जोड़ा, जो मुझे लगता है कि उपयोगिता में सुधार है (विशेष रूप से यदि आपके पास लंबी कक्षा के नाम हैं)।

एक मॉड्यूल में बेस क्लास को परिभाषित करें:

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

मैं CLASS.__bases__ का उपयोग करने की सलाह 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()

यदि आप नहीं जानते कि आपको कितने तर्क मिल सकते हैं, और उन्हें बच्चे के माध्यम से भी पास करना चाहते हैं:

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

(से: पायथन - __init__ को ओवरराइड करने का सबसे साफ तरीका जहां सुपर () कॉल के बाद एक वैकल्पिक क्वॉर्ग का उपयोग किया जाना चाहिए? )



सुपर () का उपयोग करने का एक उदाहरण यहां दिया गया है:

#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




object