एक ओवरराइड विधि को कॉल करना, एक कॉल ओवरराइड विधि सुपरक्लास

Question

यह कोड अपवाद फेंकता है, विशेषता त्रुटि, "wtf!", क्योंकि A.foo()B.foo1() पर कॉल कर रहा है, क्या इसे A.foo1() पर कॉल नहीं करना चाहिए? मैं कैसे A.foo1() कॉल करने के लिए यह मजबूर कर सकते हैं (और A.foo() अंदर किसी भी विधि कॉल A.* बुलाना चाहिए)

class A(object): 
    def foo(self): 
     print self.foo1() 

    def foo1(self): 
     return "foo" 

class B(A): 
    def foo1(self): 
     raise AttributeError, "wtf!" 

    def foo(self): 
     raise AttributeError, "wtf!" 

    def foo2(self): 
     super(B, self).foo() 

myB = B() 
myB.foo2() 

Answer 1

यह इरादा के रूप में काम कर रहा है दुनिया प्रोग्रामिंग भाषाओं काम की 100% के रूप में। Subclass माता-पिता वर्ग के सभी तरीकों को ओवरराइड करता है।

हालांकि यदि आप वास्तव में वास्तव में एफू 1() को कॉल करना चाहते हैं तो आप इसे ऐसा करने में सक्षम हो सकते हैं (मैं गारंटी नहीं दे सकता)। और किसी भी मामले में आपको ऐसा नहीं करना चाहिए क्योंकि यह अच्छे प्रोग्रामिंग के सभी सिद्धांतों के खिलाफ है।

class A(object): 

    def foo(self): 
     A.foo1(self) 

Answer 2

कोड में:

def foo2(self): 
    super(B, self).foo() 

स्वयं बी

का एक उदाहरण के लिए एक विधि एक से प्राप्त बी का एक उदाहरण यह से नाम स्थान में देख शुरू कर देंगे से पुकारा जाता है जब है बी, और केवल यदि विधि नहीं पाया जाता है (उदाहरण के लिए बी द्वारा ओवरराइड नहीं है) एक से कार्यान्वयन प्रयोग किया जाता है, लेकिन हमेशा स्वयं कोई मतलब नहीं स्वयं पर बी की चर्चा करते हुए के साथ ए

Answer 3

का एक उदाहरण है में कक्षा 0 self विधियों को कॉल करने के बजाय आपको A विधियों को कॉल करने और self पर मैन्युअल रूप से पास करने की आवश्यकता है।

यह चीजों को करने का सामान्य तरीका नहीं है - आपको वास्तव में इस तरह ऐसा करने का अच्छा कारण होना चाहिए।

class A(object): 
    def foo(self): 
     print A.foo1(self) 

    def foo1(self): 
     return "foo" 

class B(A): 
    def foo1(self): 
     raise AttributeError, "wtf!" 

    def foo(self): 
     raise AttributeError, "wtf!" 

    def foo2(self): 
     super(B, self).foo() 

myB = B() 
myB.foo2() 

Answer 4

कोई देख सकता है कि पाइथन यहां क्या कर रहा है, लेकिन ओवरराइडिंग का तरीका थोड़ा चरम है। इस मामले को लें जब कक्षा ए 100 विशेषताओं को परिभाषित करता है और कक्षा बी इन्हें प्राप्त करता है और 1 और विशेषता जोड़ता है। हम एक के लिए बी कॉल __init __() के लिए __init __() और बी के कोड केवल अपने एकल विशेषता परिभाषित जाने के लिए सक्षम होना चाहते हैं। इसी तरह, अगर हम एक में एक रीसेट() विधि शून्य करने के लिए सभी विशेषताओं सेट करने के लिए परिभाषित करते हैं, तो B के लिए इसी रीसेट() विधि एक के लिए विधि रीसेट() कॉल करने के लिए बस में सक्षम है और इसके बजाय एकल बी विशेषता को शून्य होना चाहिए तो ए के सभी कोड डुप्लिकेट करने के लिए। पाइथन मुश्किल बना रहा है जिसे वस्तु-उन्मुख प्रोग्रामिंग का एक बड़ा फायदा माना जाता है; वह है, कोड का पुन: उपयोग। यहां सबसे अच्छा विकल्प उन विधियों को ओवरराइड करने से बचाना है जिन्हें हम वास्तव में पुन: उपयोग करना चाहते हैं।

class X(object): 
    def __init__ (self): 
     print "X" 
     self.x = 'x' 
     self.reset() 
     print "back to X" 
    def reset (self): 
     print "reset X" 
     self.xx = 'xx' 

class Y(X): 
    def __init__ (self): 
     print "Y" 
     super(Y,self).__init__() 
     self.y = 'y' 
     self.reset() 
     print "back to Y" 
    def reset (self): 
     print "reset Y" 
     super(Y,self).reset() 
     print "back to reset Y" 
     self.yy = 'yy' 

aY = Y() 

(यह काम ठीक से करने के लिए, self.reset() वर्ग वाई के लिए __init __ में कॉल() निकालने के लिए)

: तुम यहाँ अजगर के साथ जटिलताओं की समझ प्राप्त करना चाहते हैं, इस कोड की कोशिश