पायथन में मैजिक मेथड्स के लिए गाइड

यह Rafe Kettler द्वारा मैनुअल के 1.17 संस्करण का अनुवाद है।

सामग्री

1. प्रविष्टि
2. डिजाइन और आरंभीकरण
3. ऑपरेटरों को मनमानी कक्षाओं पर काबू करना
   • जादुई तुलना के तरीके
   • संख्यात्मक जादू की विधियाँ
4. उनकी कक्षाओं की प्रस्तुति
5. अभिगम नियंत्रण पर ध्यान दें
6. कस्टम क्रम बनाएँ
7. प्रतिबिंब
8. वस्तुओं को बुलाया
9. प्रसंग प्रबंधक
10. सार आधार वर्ग
11. भवन विवरणक
12. नकल
13. अपनी वस्तुओं पर अचार मॉड्यूल का उपयोग करना
14. निष्कर्ष
15. परिशिष्ट 1: मैजिक मेथड्स को कैसे कॉल करें
16. परिशिष्ट 2: पायथन 3 में परिवर्तन

प्रविष्टि

जादू के तरीके क्या हैं? वे सभी ऑब्जेक्ट ओरिएंटेड पायथन में हैं। ये विशेष विधियाँ हैं जिनके साथ आप अपनी कक्षाओं में "जादू" जोड़ सकते हैं। उन्हें हमेशा दो अंडरस्कोर द्वारा तैयार किया जाता है (उदाहरण के लिए, __init__ या __lt__ )। इसके अलावा, वे उतने प्रलेखित नहीं हैं जितना हम चाहते हैं। सभी जादू के तरीके प्रलेखन में वर्णित हैं, लेकिन बहुत यादृच्छिक रूप से और लगभग किसी भी संगठन के बिना। इसलिए, पायथन डॉक्यूमेंटेशन की कमी के रूप में मैं जो भी अनुभव करता हूं, उसे ठीक करने के लिए, मैं जादू के तरीकों के बारे में अधिक जानकारी प्रदान करने जा रहा हूं, जो समझने योग्य भाषा में लिखा गया है और उदाहरणों के साथ बड़े पैमाने पर आपूर्ति की गई है। मुझे आशा है कि आप इस गाइड का आनंद लेंगे। इसे एक प्रशिक्षण सामग्री, मेमो, या पूर्ण विवरण के रूप में उपयोग करें। मैंने बस जादू के तरीकों का यथासंभव स्पष्ट वर्णन करने का प्रयास किया।

डिजाइन और आरंभीकरण।

हर कोई सबसे बुनियादी जादू विधि जानता है, __init__ । इसके साथ, हम ऑब्जेक्ट को इनिशियलाइज़ कर सकते हैं। हालाँकि, जब मैं x = SomeClass() हूं, तो __init__ बुलाया जाना पहली बात नहीं है। वास्तव में, ऑब्जेक्ट का एक उदाहरण __new__ मेथड बनाता है, और फिर इनिशियलाइज़र को तर्क दिया जाता है। ऑब्जेक्ट के जीवन चक्र के दूसरे छोर पर __del__ विधि है। आइए इन तीन जादुई तरीकों पर एक नज़र डालें:

• __new__(cls, [...)
  यह पहली विधि है जिसे ऑब्जेक्ट के प्रारंभ होने पर कहा जाएगा। यह एक वर्ग को पैरामीटर के रूप में लेता है और फिर __init__ को पारित किए जाने वाले अन्य तर्क। __new__ उपयोग बहुत कम ही किया जाता है, लेकिन यह कभी-कभी उपयोगी होता है, विशेष रूप से, जब एक वर्ग को एक अपरिवर्तनीय प्रकार से विरासत में लिया जाता है, जैसे कि एक टुपल या स्ट्रिंग। मैं __new__ में __new__ पर रहने का इरादा नहीं करता हूं, क्योंकि ऐसा नहीं है कि इसकी बहुत बार आवश्यकता होती है, लेकिन इस पद्धति को बहुत अच्छी तरह से और प्रलेखन में विस्तार से वर्णित किया गया है ।
  
  
• __init__(self, [...)
  क्लास इनिशियलाइज़र। मूल कंस्ट्रक्टर को जिस चीज के साथ बुलाया गया था, उसे पास कर दिया जाता है (उदाहरण के लिए, अगर हम x = SomeClass(10, 'foo') , तो __init__ को 10 और 'foo' को तर्क के रूप में प्राप्त होगा। __init__ लगभग सार्वभौमिक रूप से तब उपयोग किया जाता है जब कक्षाओं को परिभाषित करते समय उपयोग किया जाता है।
  
  
• __del__(self)
  यदि __new__ और __new__ एक वस्तु के निर्माता का निर्माण करते हैं, तो __del__ इसका विध्वंसक है। यह del x एक्सप्रेशन के लिए व्यवहार को परिभाषित नहीं करता है (इसलिए, यह कोड x.__del__() बराबर नहीं है)। बल्कि, यह उस समय के ऑब्जेक्ट के व्यवहार को निर्धारित करता है जब ऑब्जेक्ट कचरा कलेक्टर में प्रवेश करता है। यह उन वस्तुओं के लिए काफी सुविधाजनक हो सकता है जिन्हें हटाने के दौरान अतिरिक्त सफाई की आवश्यकता हो सकती है, जैसे सॉकेट या फ़ाइल ऑब्जेक्ट। हालाँकि, किसी को सावधान रहना चाहिए, क्योंकि इस बात की कोई गारंटी नहीं है कि __del__ कहा जाएगा यदि ऑब्जेक्ट तब भी जीवित रहता है जब दुभाषिया बंद हो जाता है। इसलिए, __del__ अच्छी प्रोग्रामिंग प्रथाओं के लिए एक विकल्प के रूप में काम नहीं कर सकता (हमेशा कनेक्शन समाप्त कर सकता है यदि आपने इसके साथ काम किया है और इसी तरह)। वास्तव में, कॉल गारंटी की कमी के कारण, __del__ का लगभग उपयोग नहीं किया जाना चाहिए; सावधानी से इसका उपयोग करें!
  
  अनुवादक से नोट: svetlov ध्यान दें कि लेखक के यहाँ गलती है, वास्तव में, __del__ हमेशा दुभाषिए के पूरा होने पर बुलाया जाता है।
  
  

यह सब एक साथ __del__ , यहाँ __del__ और __del__ का उदाहरण __init__ गया है:

 from os.path import join class FileObject: '''   ,     ,      .''' def __init__(self, filepath='~', filename='sample.txt'): #   filename  filepath      self.file = open(join(filepath, filename), 'r+') def __del__(self): self.file.close() del self.file 

ऑपरेटरों को मनमानी कक्षाओं पर काबू करना

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

 if instance.equals(other_instance): # do something 

बेशक, आप पायथन में भी ऐसा कर सकते हैं, लेकिन इससे भ्रम और अनावश्यक क्रियाशीलता बढ़ जाती है। अलग-अलग पुस्तकालयों को एक ही संचालन को अलग-अलग तरीकों से कॉल किया जा सकता है, प्रोग्रामर का उपयोग करके उन्हें आवश्यकता से अधिक कार्य करने के लिए मजबूर किया जाता है। जादू के तरीकों की शक्ति का उपयोग करके, हम वांछित विधि ( __eq__ , इस मामले में) निर्धारित कर सकते हैं, और इतनी सटीक रूप से व्यक्त करते हैं कि हमारे पास क्या था :

 if instance == other_instance: #do something 

यह जादुई तरीकों की ताकत में से एक है। उनमें से अधिकांश हमें यह निर्धारित करने की अनुमति देते हैं कि मानक ऑपरेटर क्या करेंगे, ताकि हम अपनी कक्षाओं में ऑपरेटरों का उपयोग कर सकें जैसे कि वे अंतर्निहित प्रकार थे।

जादुई तुलना के तरीके

पायथन में कई जादुई तरीके हैं, जो संचालकों का उपयोग करने वाली वस्तुओं के बीच सहज तुलना को परिभाषित करने के लिए डिज़ाइन किए गए हैं, न कि अनाड़ी तरीके से। इसके अलावा, वे वस्तुओं (संदर्भ द्वारा) की तुलना करने के लिए पायथन के डिफ़ॉल्ट व्यवहार को ओवरराइड करने का एक तरीका प्रदान करते हैं। यहाँ इन तरीकों की एक सूची है और वे क्या करते हैं:

• __cmp__(self, other)
  तुलना के तरीकों का सबसे बुनियादी। यह, वास्तव में, सभी तुलना ऑपरेटरों (>, ==; =;, आदि) के लिए व्यवहार को निर्धारित करता है, लेकिन हमेशा जिस तरह से आपको इसकी आवश्यकता नहीं होती है (उदाहरण के लिए, यदि दो उदाहरणों की समानता एक मानदंड द्वारा निर्धारित की जाती है, और फिर एक किसी अन्य के लिए दूसरा)। __cmp__ को एक ऋणात्मक संख्या वापस करनी चाहिए यदि self < other , शून्य यदि self == other , और एक सकारात्मक संख्या यदि self > other । लेकिन, आमतौर पर, प्रत्येक तुलना को परिभाषित करने के लिए बेहतर है कि आप उन सभी को __cmp__ में परिभाषित करें। लेकिन __cmp__ पुनरावृत्ति से बचने और स्पष्टता बढ़ाने का एक अच्छा तरीका हो सकता है जब सभी आवश्यक तुलना एक ही मानदंड पर काम करते हैं।
  
  
• __eq__(self, other)
  समानता ऑपरेटर के व्यवहार को परिभाषित करता है, == ।
  
  
• __ne__(self, other)
  असमानता ऑपरेटर के व्यवहार को परिभाषित करता है! != ।
  
  
• __lt__(self, other)
  ऑपरेटर के व्यवहार को कम परिभाषित करता है, < ।
  
  
• __gt__(self, other)
  ऑपरेटर के व्यवहार को अधिक परिभाषित करता है, > ।
  
  
• __le__(self, other)
  ऑपरेटर के व्यवहार को परिभाषित करता है <= बराबर या उससे कम।
  
  
• __ge__(self, other)
  ऑपरेटर के व्यवहार को >= से अधिक या उसके बराबर परिभाषित करता है।
  
  

उदाहरण के लिए, किसी शब्द का वर्णन करने वाले वर्ग पर विचार करें। हम शब्द की तुलनात्मक रूप से (वर्णानुक्रम में) कर सकते हैं, जो कि स्ट्रिंग की तुलना करते समय डिफ़ॉल्ट व्यवहार है, लेकिन हम तुलना करते समय कुछ अन्य मानदंड का उपयोग करना चाह सकते हैं, जैसे कि शब्दांश की संख्या या संख्या। इस उदाहरण में, हम लंबाई में तुलना करेंगे। यहाँ कार्यान्वयन है:

 class Word(str): '''  ,     .''' def __new__(cls, word): #    __new__,    str  #       ( ) if ' ' in word: print "Value contains spaces. Truncating to first space." word = word[:word.index(' ')] #  Word       return str.__new__(cls, word) def __gt__(self, other): return len(self) > len(other) def __lt__(self, other): return len(self) < len(other) def __ge__(self, other): return len(self) >= len(other) def __le__(self, other): return len(self) <= len(other) 

अब हम दो Word ( Word('foo') और Word('bar') का उपयोग करके Word('foo') बना सकते हैं और उनकी तुलना लंबाई में कर सकते हैं। ध्यान दें कि हमने __eq__ और __ne__ को परिभाषित नहीं किया है, क्योंकि इससे अजीब व्यवहार होगा (उदाहरण के लिए, Word('foo') == Word('bar') को सच माना जाएगा)। लंबाई के आधार पर तुल्यता के लिए परीक्षण करते समय इसका कोई मतलब नहीं है, इसलिए हम मानक समतुल्यता परीक्षण को str से छोड़ देते हैं।
अब, यह उल्लेख करने का एक अच्छा समय है कि आपको तुलना के सभी जादुई तरीकों को परिभाषित करने की आवश्यकता नहीं है ताकि सभी तुलनाओं को पूरी तरह से कवर किया जा सके। मानक पुस्तकालय कृपया हमें functools मॉड्यूल में एक डेकोरेटर वर्ग प्रदान करता है, जो सभी तुलना विधियों को निर्धारित करेगा, यह आपके लिए केवल __eq__ और एक और ( __gt__ , __lt__ , आदि) को परिभाषित करने के लिए पर्याप्त है। यह सुविधा पायथन के संस्करण 2.7 से शुरू होती है, लेकिन यदि यह उपलब्ध है आप संतुष्ट हैं, आप बहुत समय और प्रयास बचाएंगे। इसे सक्षम करने के लिए, अपनी श्रेणी परिभाषा में @total_ordering ।

संख्यात्मक जादू की विधियाँ

जैसे आप यह निर्धारित कर सकते हैं कि आपकी वस्तुओं की तुलना ऑपरेटरों द्वारा कैसे की जाएगी, आप संख्यात्मक ऑपरेटरों के लिए उनके व्यवहार को परिभाषित कर सकते हैं। तैयार हो जाओ, दोस्तों, उनमें से कई हैं। एक बेहतर संगठन के लिए, मैंने संख्यात्मक जादू विधियों को 5 श्रेणियों में विभाजित किया है: एकरी ऑपरेटर, साधारण अंकगणितीय ऑपरेटर, प्रतिबिंबित अंकगणित ऑपरेटर (अधिक विवरण बाद में), यौगिक कार्य और प्रकार रूपांतरण।

गैरी ऑपरेटरों और कार्यों

यूनिरी संचालकों और कार्यों का केवल एक ही संचालन होता है - निषेध, निरपेक्ष मूल्य, और इसी तरह।

• __pos__(self)
+some_object प्लस ( +some_object ) के लिए व्यवहार को परिभाषित करता है
  
  
• __neg__(self)
  नकार व्यवहार को परिभाषित करता है ( -some_object )
  
  
• __abs__(self)
  एब्स abs() निर्मित फ़ंक्शन के लिए व्यवहार को परिभाषित करता है।
  
  
• __invert__(self)
~ ऑपरेटर द्वारा उल्टे किए जाने वाले व्यवहार को परिभाषित करता है। वह क्या कर रहा है, इसकी व्याख्या के लिए, बाइनरी ऑपरेटरों पर विकिपीडिया लेख देखें।
  
  
• __round__(self, n)
  अंतर्निहित round() फ़ंक्शन के लिए व्यवहार को परिभाषित करता है। n दशमलव स्थानों की संख्या है जिसे गोल करना है।
  
  
• __floor__(self)
math.floor() लिए व्यवहार को परिभाषित करता है, अर्थात, निकटतम छोटे पूर्णांक के लिए गोलाई।
  
  
• __ceil__(self)
math.ceil() लिए व्यवहार को परिभाषित करता है, यानी निकटतम बड़े पूर्णांक के लिए गोलाई।
  
  
• __trunc__(self)
math.trunc() लिए व्यवहार को परिभाषित करता है, जो पूर्णांक को ट्रिम कर रहा है।
  
  

आम अंकगणित संचालक

अब सामान्य बाइनरी ऑपरेटर्स (और कुछ और फ़ंक्शंस) पर विचार करें: +, -, * और इसी तरह के अन्य। वे, अधिकांश भाग के लिए, खुद का पूरी तरह से वर्णन करते हैं।

• __add__(self, other)
  इसके अलावा।
  
  
• __sub__(self, other)
  घटाव।
  
  
• __mul__(self, other)
  गुणन।
  
  
• __floordiv__(self, other)
  इंटेगर डिवीजन, ऑपरेटर // ।
  
  
• __div__(self, other)
  विभाग, संचालक।
  
  
• __truediv__(self, other)
  सही विभाजन। ध्यान दें कि यह केवल तभी काम करता है जब from __future__ import division ।
  
  
• __mod__(self, other)
  शेष संचालक % ।
  
  
• __divmod__(self, other)
  अंतर्निहित divmod() फ़ंक्शन के लिए व्यवहार को परिभाषित करता है।
  
  
• __pow__
  विस्तार, ऑपरेटर ** ।
  
  
• __lshift__(self, other)
  बाइनरी बाईं पारी, ऑपरेटर << ।
  
  
• __rshift__(self, other)
  दाईं ओर बाइनरी शिफ्ट, ऑपरेटर >> ।
  
  
• __and__(self, other)
  बाइनरी और, & ऑपरेटर।
  
  
• __or__(self, other)
  बाइनरी या ऑपरेटर | ।
  
  
• __xor__(self, other)
  बाइनरी एक्सोर, ऑपरेटर ^ ।
  
  

प्रतिबिंबित अंकगणितीय संचालक

याद रखें कि मैंने कैसे कहा कि मैं प्रतिबिंबित अंकगणित पर अधिक विस्तार से ध्यान केंद्रित करने जा रहा था? आप सोच सकते हैं कि यह किसी प्रकार की बड़ी, डरावनी और समझ से बाहर की अवधारणा है। वास्तव में, सब कुछ बहुत सरल है। यहाँ एक उदाहरण है:

 some_object + other 

यह एक "सामान्य" जोड़ है। समतुल्य परिलक्षित अभिव्यक्ति के बीच एकमात्र अंतर शब्दों का क्रम है:

 other + some_object 

इस प्रकार, ये सभी जादू के तरीके अपने नियमित संस्करणों के समान हैं, other रूप में other साथ ऑपरेशन करने के अपवाद के रूप में और दूसरे के रूप में self । ज्यादातर मामलों में, परिलक्षित ऑपरेशन का परिणाम इसके सामान्य समकक्ष के समान होता है, इसलिए __radd__ को परिभाषित करते __radd__ आप खुद को __add__ और उस पर कॉल करने के लिए सीमित कर सकते हैं। ध्यान दें कि ऑपरेटर के बाईं ओर की वस्तु (उदाहरण में other ) में इस विधि का सामान्य रूप से अपरिष्कृत संस्करण नहीं होना चाहिए। हमारे उदाहरण में, some_object.__radd__ केवल तभी कहा जाएगा यदि __add__ other में परिभाषित नहीं किया गया है।

• __radd__(self, other)
  इसके अलावा परावर्तित।
  
  
• __rsub__(self, other)
  परावर्तन घटाव।
  
  
• __rmul__(self, other)
  प्रतिबिंबित गुणा।
  
  
• __rfloordiv__(self, other)
  प्रतिबिंबित पूर्णांक विभाजन, ऑपरेटर // ।
  
  
• __rdiv__(self, other)
  परावर्तित प्रभाग, संचालक।
  
  
• __rtruediv__(self, other)
  सही विभाजन को दर्शाया गया। ध्यान दें कि केवल तभी काम करता है जब from __future__ import division ।
  
  
• __rmod__(self, other)
  डिविजन का शेष भाग, ऑपरेटर % ।
  
  
• __rdivmod__(self, other)
divmod() फ़ंक्शन के लिए व्यवहार को परिभाषित करता है जब divmod(other, self) कहा जाता है।
  
  
• __rpow__
  स्टेपी, ऑपरेटर ** लिए परिलक्षित ऊंचाई।
  
  
• __rlshift__(self, other)
  प्रतिबिंबित बाइनरी बाईं पारी, ऑपरेटर << ।
  
  
• __rrshift__(self, other)
  सही, ऑपरेटर >> लिए परिलक्षित बाइनरी पारी।
  
  
• __rand__(self, other)
  प्रतिबिंबित बाइनरी और, & ऑपरेटर।
  
  
• __ror__(self, other)
  परिलक्षित बाइनरी या ऑपरेटर | ।
  
  
• __rxor__(self, other)
  प्रतिबिंबित बाइनरी एक्सोर, ऑपरेटर ^ ।
  
  
  

यौगिक कार्य

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

 x = 5 x += 1 #   x = x + 1 

इन विधियों में से प्रत्येक को एक मान वापस करना चाहिए जो बाईं ओर चर को सौंपा जाएगा (उदाहरण के लिए, a += b , __iadd__ को a + b लौटना चाहिए, जिसे a को सौंपा जाएगा)। यहाँ सूची है:

• __iadd__(self, other)
  असाइनमेंट के साथ असाइनमेंट।
  
  
• __isub__(self, other)
  असाइनमेंट के साथ घटाव।
  
  
• __imul__(self, other)
  असाइनमेंट गुणन।
  
  
• __ifloordiv__(self, other)
  असाइनमेंट, ऑपरेटर //= साथ पूर्णांक विभाजन।
  
  
• __idiv__(self, other)
  असाइनमेंट, ऑपरेटर /= साथ डिवीजन।
  
  
• __itruediv__(self, other)
  असाइनमेंट के साथ सही विभाजन। ध्यान दें कि केवल तभी काम करता है यदि from __future__ import division ।
  
  
• __imod_(self, other)
  असाइनमेंट डिवीजन का परिचालक, ऑपरेटर %= ।
  
  
• __ipow__
  असाइनमेंट के साथ स्टेपी में विस्तार करना, ऑपरेटर **= ।
  
  
• __ilshift__(self, other)
  असाइनमेंट, ऑपरेटर के साथ बाइनरी बाईं पारी <<= ।
  
  
• __irshift__(self, other)
  असाइनमेंट, ऑपरेटर के साथ बाइनरी राइट शिफ्ट >>= ।
  
  
• __iand__(self, other)
  बाइनरी और असाइनमेंट, ऑपरेटर &= ।
  
  
• __ior__(self, other)
  बाइनरी या असाइनमेंट, ऑपरेटर के साथ |= |
  
  
• __ixor__(self, other)
  असाइनमेंट, ऑपरेटर ^= साथ बाइनरी एक्सर ^= ।
  
  
  

रूपांतरण मैजिक विधियाँ लिखें

इसके अलावा, पायथन में निर्मित प्रकार के रूपांतरण कार्यों के लिए व्यवहार को परिभाषित करने के कई जादू के तरीके हैं, जैसे कि float() । यहाँ वे हैं:

• __int__(self)
  इंट में रूपांतरण टाइप करें।
  
  
• __long__(self)
  रूपांतरण को लंबे समय तक टाइप करें।
  
  
• __float__(self)
  फ्लोट में रूपांतरण टाइप करें।
  
  
• __complex__(self)
  एक प्रकार को एक जटिल संख्या में बदलना।
  
  
• __oct__(self)
  अष्टक संख्या में परिवर्तित प्रकार।
  
  
• __hex__(self)
  एक प्रकार को हेक्साडेसिमल संख्या में परिवर्तित करना।
  
  
• __index__(self)
  किसी वस्तु को स्लाइस में प्रयुक्त करने के लिए एक प्रकार को int में परिवर्तित करना (प्रपत्र की अभिव्यक्ति [प्रारंभ: स्टॉप: स्टेप])। यदि आप अपने नंबर प्रकार को परिभाषित कर रहे हैं, जिसका उपयोग सूची सूचकांक के रूप में किया जा सकता है, तो आपको __index__ को परिभाषित करना होगा।
  
  
• __trunc__(self)
math.trunc(self) साथ कॉल किया जाता है। पूर्णांक प्रकार (आमतौर पर लंबे समय) में काट दिया गया मान वापस करना चाहिए।
  
  
• __coerce__(self, other)
  विभिन्न प्रकार के ऑपरेंड के साथ अंकगणित को लागू करने की विधि। यदि प्रकार रूपांतरण संभव नहीं है तो __coerce__ को None __coerce__ चाहिए। यदि रूपांतरण संभव है, तो इसे self और other से एक जोड़ी (2 तत्वों का एक टपल) लौटाया जाना चाहिए, एक ही प्रकार में परिवर्तित।
  
  

उनकी कक्षाओं की प्रस्तुति

एक स्ट्रिंग के रूप में एक वर्ग का प्रतिनिधित्व करना अक्सर उपयोगी होता है। पायथन में कई विधियां हैं जिन्हें आप अपनी कक्षा का प्रतिनिधित्व करते समय इनलाइन कार्यों के व्यवहार को अनुकूलित करने के लिए परिभाषित कर सकते हैं।

• __str__(self)
  अपने वर्ग के उदाहरण के लिए कहे गए str() फ़ंक्शन के व्यवहार को परिभाषित करता है।
  
  
• __repr__(self)
  अपने वर्ग के एक उदाहरण के लिए repr() कार्य repr() के व्यवहार को परिभाषित करता है। लक्षित दर्शकों में str() से मुख्य अंतर। repr() मशीन-उन्मुख आउटपुट के लिए अधिक है (इसके अलावा, इसे अक्सर वैध पायथन कोड होना चाहिए), और str() लोगों को पढ़ने के लिए है।
  
  
• __unicode__(self)
unicode() फ़ंक्शन के व्यवहार को आपके वर्ग के उदाहरण के लिए बुलाया गया है। unicode() स्ट्रिंग की तरह है str() , लेकिन यह यूनिकोड में एक स्ट्रिंग देता है। सावधान रहें: यदि क्लाइंट आपकी कक्षा के एक उदाहरण पर str() कॉल करता है, और आपने केवल __unicode__() परिभाषित किया है, तो यह काम नहीं करेगा। उस मामले के लिए हमेशा __str__() को परिभाषित करने का प्रयास करें जब किसी के पास यूनिकोड की विलासिता न हो।
  
  
• __format__(self, formatstr)
  व्यवहार को परिभाषित करता है जब आपकी कक्षा का एक उदाहरण नई शैली के तार को स्वरूपित करने में उपयोग किया जाता है। उदाहरण के लिए, "Hello, {0:abc}!".format(a) का कारण होगा a.__format__("abc") बुलाया a.__format__("abc") । यह आपके स्वयं के संख्यात्मक या स्ट्रिंग प्रकारों को परिभाषित करने के लिए उपयोगी हो सकता है जिनमें आप कुछ विशेष स्वरूपण विकल्प प्रदान करना चाहते हैं।
  
  
• __hash__(self)
  अपने वर्ग के उदाहरण के लिए बुलाए गए hash() फ़ंक्शन के व्यवहार को परिभाषित करता है। विधि को एक पूर्णांक मान वापस करना चाहिए जिसका उपयोग शब्दकोशों में कुंजियों की जल्दी से तुलना करने के लिए किया जाएगा। ध्यान दें कि इस मामले में आपको आमतौर पर __eq__ भी परिभाषित __eq__ । निम्नलिखित नियम का प्रयोग करें: a == b अर्थ hash(a) == hash(b) ।
  
  
• __nonzero__(self)
  अपनी कक्षा के उदाहरण के लिए कहे गए bool() फ़ंक्शन के व्यवहार को परिभाषित करता है। जब आप उदाहरण को सत्य या गलत मानते हैं, तो यह सही या गलत लौटना चाहिए।
  
  
• __dir__(self)
  अपने वर्ग के एक उदाहरण पर बुलाया dir() फ़ंक्शन के व्यवहार को परिभाषित करता है। इस विधि को उपयोगकर्ता को विशेषताओं की एक सूची वापस देनी चाहिए। आम तौर पर, __dir__ परिभाषित __dir__ आवश्यक नहीं है, लेकिन यदि आप __getattr__ या __getattribute__ (जो आप अगले भाग में मिलेंगे) को फिर से परिभाषित __getattr__ , या अन्यथा गतिशील रूप से विशेषताएँ करते हैं, तो यह आपकी कक्षा के इंटरैक्टिव उपयोग के लिए महत्वपूर्ण हो सकता है।
  
  
• __sizeof__(self)
  अपने वर्ग के एक उदाहरण पर sys.getsizeof() फ़ंक्शन के व्यवहार को परिभाषित करता है। विधि को बाइट्स में अपनी वस्तु का आकार वापस करना चाहिए। यह सी एक्सटेंशन में परिभाषित वर्गों के लिए मुख्य रूप से उपयोगी है, लेकिन इसके बारे में जानना अभी भी उपयोगी है।
  
  

हम लगभग जादुई तरीकों पर मैनुअल के उबाऊ (और उदाहरणों से रहित) के साथ कर रहे हैं। अब जब हमने सबसे बुनियादी जादू विधियों को कवर किया है, तो अधिक उन्नत सामग्री पर आगे बढ़ने का समय है।

अभिगम नियंत्रण पर ध्यान दें

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

• __getattr__(self, name)
  आप उस मामले के लिए व्यवहार को परिभाषित कर सकते हैं जब उपयोगकर्ता एक विशेषता तक पहुंचने की कोशिश करता है जो मौजूद नहीं है (बिल्कुल या अभी तक)। यह लगातार टाइपोस को इंटरसेप्ट करने और रीडायरेक्ट करने के लिए उपयोगी हो सकता है, अप्रचलित विशेषताओं के उपयोग के बारे में चेतावनी देता है (आप अभी भी इस विशेषता की गणना कर सकते हैं और यदि आप चाहते हैं तो वापस कर सकते हैं), या जब आपको ज़रूरत हो तो एक AttributeError वापस लौटा दें। सच है, इस पद्धति को केवल तब कहा जाता है जब वे एक विशेषता तक पहुंचने का प्रयास करते हैं जो मौजूद नहीं है, इसलिए यह एनकैप्सुलेशन के लिए एक अच्छा समाधान नहीं है।
  
  
• __setattr__(self, name, value)
__getattr__ विपरीत, __setattr__ समाधान है। यह विधि आपको किसी विशेषता के लिए मान निर्दिष्ट करने के लिए व्यवहार को परिभाषित करने की अनुमति देती है, चाहे वह विशेषता मौजूद हो या नहीं। यही है, आप मानों को बदलने के लिए किसी भी नियम को परिभाषित कर सकते हैं। हालांकि, आपको सावधान रहना चाहिए कि __setattr__ का उपयोग कैसे करें, इस सूची के अंत में एक बुरे मामले का उदाहरण देखें।
  
  
• __delattr__
  यह __setattr__ के समान है, लेकिन मूल्यों को सेट करने के बजाय, विशेषताओं को हटाने के लिए। अनंत पुनरावृत्ति से बचने के लिए __setattr__ में भी यही सावधानी बरती जाती है ( del self.name की परिभाषा में del self.name कॉल करने से अनंत पुनरावृत्ति होगी)।
  
  
• __getattribute__(self, name)
__getattribute__ अपने सहयोगियों __setattr__ और __delattr__ बीच जगह से बाहर दिखता है, लेकिन मैं आपको इसका उपयोग करने की सलाह नहीं __delattr__ । __getattribute__ केवल एक नए प्रकार की कक्षाओं के साथ उपयोग किया जा सकता है (पायथन के नए संस्करणों में, सभी कक्षाएं एक नए प्रकार की हैं, और पुराने संस्करणों में आप इस तरह की कक्षा को object से प्राप्त कर सकते हैं)। ( , __getattr__(self, name) ). , ( __getattribute__ , ). , , __getattr__ , __getattribute__ AttributeError . ( , ), , , ( , ) .
  
  

विशेषताओं तक पहुंच को नियंत्रित करने वाली किसी भी विधि को परिभाषित करते समय आप आसानी से एक समस्या प्राप्त कर सकते हैं। एक उदाहरण पर विचार करें:

 def __setattr__(self, name, value): self.name = value #  ,    ,     , #  __setattr__(). # ,      self.__setattr__('name', value). #      ,   ,     def __setattr__(self, name, value): self.__dict__[name] = value #      #     

एक बार फिर, पायथन में जादुई तरीकों की शक्ति अविश्वसनीय है, और बड़ी शक्ति के साथ बड़ी जिम्मेदारी आती है। यह जानना महत्वपूर्ण है कि किसी भी चीज को तोड़ने के बिना जादू के तरीकों का सही तरीके से उपयोग कैसे करें।

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

 class AccessCounter(object): ''',   value      .    ,   value.''' def __init__(self, val): super(AccessCounter, self).__setattr__('counter', 0) super(AccessCounter, self).__setattr__('value', val) def __setattr__(self, name, value): if name == 'value': super(AccessCounter, self).__setattr__('counter', self.counter + 1) #      . #       , #   AttributeError(name) super(AccessCounter, self).__setattr__(name, value) def __delattr__(self, name): if name == 'value': super(AccessCounter, self).__setattr__('counter', self.counter + 1) super(AccessCounter, self).__delattr__(name)] 

कस्टम क्रम बनाएँ

पायथन में, आपकी कक्षाओं को इनलाइन दृश्यों (शब्दकोशों, ट्यूपल्स, सूचियों, तार, और इसी तरह) के रूप में व्यवहार करने के कई तरीके हैं। ये, निश्चित रूप से, मेरे पसंदीदा जादुई तरीके हैं, क्योंकि वे जो उच्च स्तर का नियंत्रण देते हैं और जिस जादू से वैश्विक कार्यों की एक पूरी मेजबानी अचानक आपकी कक्षाओं के उदाहरणों के साथ पूरी तरह से काम करना शुरू कर देती है। लेकिन इससे पहले कि हम हर तरह की अच्छी चीजों में लगें, हमें प्रोटोकॉल के बारे में जानना होगा।

प्रोटोकॉल

अब जब यह पायथन में अपने स्वयं के अनुक्रम बनाने के बारे में है, तो प्रोटोकॉल के बारे में बात करने का समय है । प्रोटोकॉल अन्य भाषाओं में इंटरफेस की तरह एक सा है जिसमें वे उन तरीकों का एक सेट प्रदान करते हैं जिन्हें आपको लागू करना चाहिए। हालांकि, पायथन में, प्रोटोकॉल बिल्कुल कुछ भी उपकृत नहीं करते हैं और किसी भी घोषणा के कार्यान्वयन की आवश्यकता नहीं है। वे शायद दिशा-निर्देशों की तरह दिखते हैं।

हम प्रोटोकॉल के बारे में क्यों बात कर रहे हैं? क्योंकि पाइथन में मनमाने कंटेनर प्रकारों का कार्यान्वयन उनमें से कुछ का उपयोग करने के लिए मजबूर करता है। सबसे पहले, अपरिवर्तनीय कंटेनरों को परिभाषित करने के लिए प्रोटोकॉल: एक अपरिवर्तनीय कंटेनर बनाने के लिए, आपको केवल परिभाषित करने की आवश्यकता है __len__और__getitem__(उनके बारे में और आगे)। उत्परिवर्तित कंटेनर प्रोटोकॉल को अपरिवर्तनीय कंटेनर, प्लस __setitem__और के समान होना चाहिए __delitem__। और अंत में, यदि आप चाहते हैं कि आपकी वस्तुएं पुनरावृत्त हों, तो आपको यह निर्धारित करना चाहिए कि __iter__कौन से पुनरावृत्त रिटर्न। इस इटरेटर को इटरेटर प्रोटोकॉल के अनुरूप होना चाहिए, जिसमें तरीकों की आवश्यकता होती है __iter__(खुद ही रिटर्न) और next।

कंटेनर का जादू

आगे की देरी के बिना, यहां कंटेनरों द्वारा उपयोग किए जाने वाले जादू के तरीके हैं:

• __len__(self)
  कंटेनर में आइटम की संख्या लौटाता है। उत्परिवर्तनीय और अपरिवर्तनीय कंटेनरों के लिए प्रोटोकॉल का हिस्सा।
  
  
• __getitem__(self, key)
  , self[key] . . : TypeError KeyError .
  
  
• __setitem__(self, key, value)
  , self[nkey] = value . . , KeyError TypeError .
  
  
• __delitem__(self, key)
  ( del self[key] ). . , .
  
  
• __iter__(self)
  . , iter() for x in container: . __iter__ , self .
  
  
• __reversed__(self)
reversed() . . , .
  
  
• __contains__(self, item)
__contains__का उपयोग कर एक तत्व के स्वामित्व को सत्यापित करने के लिए बनाया गया है inऔर not in। आप पूछ सकते हैं कि यह अनुक्रम प्रोटोकॉल का हिस्सा क्यों नहीं है? क्योंकि जब __contains__परिभाषित नहीं किया जाता है, तो पायथन बस तत्व द्वारा पूरे अनुक्रम तत्व पर पुनरावृत्ति करता है और Trueअगर यह सही पाता है तो वापस लौटता है ।
  
  
• __missing__(self, key)
__missing__से वार करते समय उपयोग किया जाता है dict। यह प्रत्येक मामले के लिए व्यवहार को निर्धारित करता है जब वे एक तत्व को एक अलंकृत कुंजी द्वारा प्राप्त करने का प्रयास करते हैं (उदाहरण के लिए, अगर मेरे पास एक शब्दकोष है dऔर मैं लिखता हूं d["george"]जब "george"यह शब्दकोष में कुंजी नहीं है, तो इसे कहा जाता है d.__missing__("george"))।
  
  

उदाहरण

एक उदाहरण के रूप में, आइए एक सूची देखें जो कुछ कार्यात्मक निर्माणों को लागू करता है जो आप अन्य भाषाओं में आ सकते हैं (उदाहरण के लिए हास्केल)।

 class FunctionalList: '''-       : head, tail, init, last, drop, take.''' def __init__(self, values=None): if values is None: self.values = [] else: self.values = values def __len__(self): return len(self.values) def __getitem__(self, key): #      , list   return self.values[key] def __setitem__(self, key, value): self.values[key] = value def __delitem__(self, key): del self.values[key] def __iter__(self): return iter(self.values) def __reversed__(self): return FunctionalList(reversed(self.values)) def append(self, value): self.values.append(value) def head(self): #    return self.values[0] def tail(self): #      return self.values[1:] def init(self): #      return self.values[:-1] def last(self): #    return self.values[-1] def drop(self, n): #     n return self.values[n:] def take(self, n): #  n  return self.values[:n] 

() . , , , ( , ?), Counter , OrderedDict , NamedTuple .

, isinstance() issubclass() , . यहाँ वे हैं:

• __instancecheck__(self, instance)
  , ( isinstance(instance, class) , .
  
  
• __subclasscheck__(self, subclass)
  , ( issubclass(subclass, class) ).
  
  

ऐसा लग सकता है कि इन जादुई तरीकों के लाभकारी उपयोग के लिए कुछ विकल्प हैं, और शायद यह वास्तव में ऐसा है। मैं प्रतिबिंब के जादुई तरीकों पर बहुत अधिक समय नहीं बिताना चाहता, वे विशेष रूप से महत्वपूर्ण नहीं हैं, लेकिन वे पायथन में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के बारे में और सामान्य रूप से पायथन के बारे में कुछ महत्वपूर्ण दर्शाते हैं: लगभग हमेशा कुछ करने के लिए एक सरल तरीका है, यहां तक ​​कि आवश्यक भी इसमें "कुछ भी" बहुत कम ही उत्पन्न होता है। ये जादू के तरीके उपयोगी नहीं लग सकते हैं, लेकिन अगर आपको कभी भी उनकी आवश्यकता होती है, तो आपको यह याद करके खुशी होगी कि वे हैं (और इसके लिए आप यह मैनुअल पढ़ रहे हैं!)।

वस्तुओं को बुलाया

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

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

• __call__(self, [args...])
  अपनी कक्षा के किसी भी उदाहरण को एक फ़ंक्शन के रूप में बुलाया जा सकता है। इसका मुख्य रूप से मतलब है कि इसका x()मतलब उसी के समान है x.__call__()। ध्यान दें कि यह __call__एक मनमानी संख्या लेती है; यही है, आप __call__किसी भी अन्य फ़ंक्शन की तरह ही परिभाषित कर सकते हैं, जिसमें आपकी ज़रूरत के अनुसार कई तर्क हैं।
  
  

__call__विशेष रूप से, यह उन वर्गों में उपयोगी हो सकता है जिनके उदाहरण अक्सर अपनी स्थिति बदलते हैं। एक "आह्वान" उदाहरण एक वस्तु की स्थिति को बदलने के लिए एक सहज और सुरुचिपूर्ण तरीका हो सकता है। एक उदाहरण एक विमान पर एक वस्तु की स्थिति का प्रतिनिधित्व करने वाला एक वर्ग होगा:

 class Entity: ''',    . "",    .''' def __init__(self, size, x, y): self.x, self.y = x, y self.size = size def __call__(self, x, y): '''  .''' self.x, self.y = x, y # ... 

प्रसंग प्रबंधक

Python 2.5 में, एक नए कीवर्ड के साथ कोड, एक कीवर्ड का पुन: उपयोग करने के लिए एक नया तरीका पेश किया गया था with। संदर्भ प्रबंधकों की अवधारणा पायथन के लिए नई नहीं थी (इसे पहले पुस्तकालय के हिस्से के रूप में लागू किया गया था), लेकिन पीईपी 343 में इसने भाषा निर्माण की स्थिति प्राप्त की। आप पहले से ही भाव देख सकते हैं with:

 with open('foo.txt') as bar: #  -   bar 

प्रसंग प्रबंधक आपको किसी कथन में लिपटे होने पर कॉन्फ़िगर करने या साफ़ करने के लिए कुछ क्रियाएं करने की अनुमति देते हैं with। संदर्भ प्रबंधक का व्यवहार दो जादू विधियों द्वारा निर्धारित किया जाता है:

• __enter__(self)
  परिभाषित करता है कि संदर्भ प्रबंधक को कथन द्वारा बनाए गए ब्लॉक की शुरुआत में क्या करना चाहिए with। ध्यान दें कि वापसी __enter__मूल्य वह मूल्य है जिसके साथ काम अंदर किया जाता है with।
  
  
• __exit__(self, exception_type, exception_value, traceback)
  , ( ). , , with. , exception_type , exception_value , traceback None . , ; , , __exit__ True . , , .
  
  

__enter__और __exit__संसाधनों की स्थापना और समाशोधन के लिए अच्छी तरह से परिभाषित और सामान्य व्यवहार के साथ विशिष्ट वर्गों के लिए उपयोगी हो सकता है। आप इन तरीकों का उपयोग विभिन्न वस्तुओं के लिए सामान्य संदर्भ प्रबंधक बनाने के लिए कर सकते हैं। यहाँ एक उदाहरण है:

 class Closer: '''        close  with-.''' def __init__(self, obj): self.obj = obj def __enter__(self): return self.obj #     with- def __exit__(self, exception_type, exception_val, trace): try: self.obj.close() except AttributeError: #     close print 'Not closable.' return True #   

Closerएफ़टीपी कनेक्शन के साथ उपयोग का एक उदाहरण (एक सॉकेट जिसमें एक करीबी तरीका है):

 >>> from magicmethods import Closer >>> from ftplib import FTP >>> with Closer(FTP('ftp.somesite.com')) as conn: ... conn.dir() ... # output omitted for brevity >>> conn.dir() # long AttributeError message, can't use a connection that's closed >>> with Closer(int(5)) as i: ... i += 1 ... Not closable. >>> i 6 

देखें कि हमारा रैपर कैसे सही और गलत दोनों तरह की वस्तुओं को संभालता है। यह संदर्भ प्रबंधकों और जादू विधियों की शक्ति है। ध्यान दें कि मानक पायथन लाइब्रेरी में एक रेफ़्लिब मॉड्यूल शामिल होता है, जिसमें contextlib.closing()एक संदर्भ प्रबंधक शामिल होता है जो लगभग एक ही चीज़ करता है (मामले के किसी भी हैंडल के बिना जहां ऑब्जेक्ट की कोई विधि नहीं है close())।

सार आधार वर्ग

Http://docs.python.org/2/library/abc.html देखें ।

भवन विवरणक

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

एक वर्ग के लिए एक डिस्क्रिप्टर बनने के लिए, इसे कम से कम एक विधि से लागू करना चाहिए __get__, __set__या __delete__। आइए इन जादुई तरीकों को देखें:

• __get__(self, instance, instance_class)
  विवरणक से मान वापस करते समय व्यवहार को परिभाषित करता है। instanceयह वह वस्तु है जिसके लिए वर्णनकर्ता विशेषता को विधि कह रहा है। ownerयह वस्तु का प्रकार (वर्ग) है।
  
  
• __set__(self, instance, value)
  किसी डिस्क्रिप्टर से मान बदलते समय व्यवहार को परिभाषित करता है। instanceयह वह वस्तु है जिसके लिए वर्णनकर्ता विशेषता को विधि कह रहा है। valueयह मान हैंडल पर सेट है।
  
  
• __delete__(self, instance)
  किसी डिस्क्रिप्टर से मान निकालने के लिए व्यवहार को परिभाषित करता है। instanceयह वह वस्तु है जो वर्णनकर्ता का मालिक है।
  
  

अब विवरणकों के उपयोगी उपयोग का एक उदाहरण: इकाई रूपांतरण।

 class Meter(object): '''  .''' def __init__(self, value=0.0): self.value = float(value) def __get__(self, instance, owner): return self.value def __set__(self, instance, value): self.value = float(value) class Foot(object): '''  .''' def __get__(self, instance, owner): return instance.meter * 3.2808 def __set__(self, instance, value): instance.meter = float(value) / 3.2808 class Distance(object): ''',  ,       .''' meter = Meter() foot = Foot() 

नकल

पायथन में, असाइनमेंट ऑपरेटर ऑब्जेक्ट्स की प्रतिलिपि नहीं बनाता है, लेकिन केवल एक और लिंक जोड़ता है। लेकिन परस्पर तत्वों से युक्त संग्रह के लिए, कभी-कभी पूर्ण प्रतिलिपि आवश्यक होती है ताकि आप दूसरे को प्रभावित किए बिना एक अनुक्रम के तत्वों को बदल सकें। यहाँ खेलने में आता है copy। सौभाग्य से, पायथन में मॉड्यूल का दिमाग नहीं है, इसलिए हमें चिंता करने की ज़रूरत नहीं है कि वे अचानक खुद को अनियंत्रित रूप से कॉपी करना शुरू कर देंगे और जल्द ही लिनक्स रोबोट पूरे ग्रह को भर देंगे, लेकिन हमें पायथन को सही तरीके से कॉपी करने के तरीके बताने चाहिए।

• __copy__(self)
copy.copy() . copy.copy() — , , . , .
  
  
• __deepcopy__(self, memodict={})
copy.deepcopy() . copy.deepcopy() — . memodict , , . - , copy.deepcopy() memodict .
  
  

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

अपनी वस्तुओं पर अचार मॉड्यूल का उपयोग करना

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

सीरियलाइज़ेशन इतना महत्वपूर्ण है कि, इसके मॉड्यूल के अलावा ( pickle), इसके अपने प्रोटोकॉल और अपने स्वयं के जादू के तरीके हैं। लेकिन पहले, अचार का उपयोग करके मौजूदा डेटा प्रकारों को क्रमबद्ध कैसे करें (यदि आप पहले से जानते हैं तो छोड़ें)।

संक्षेप में क्रमबद्धता के बारे में

धारावाहिक में गोता लगाते हैं। मान लीजिए कि आपके पास एक ऐसा शब्दकोश है जिसे आप बाद में सहेजना और पुनर्स्थापित करना चाहते हैं। आपको इसकी सामग्री को एक फ़ाइल में लिखना होगा, यह सुनिश्चित करते हुए कि आप सही वाक्यविन्यास के साथ लिख रहे हैं, फिर इसे पुनर्स्थापित करें, या तो exec()फ़ाइल को निष्पादित करके या पढ़कर। लेकिन यह सबसे अच्छा जोखिम भरा है: यदि आप पाठ में महत्वपूर्ण डेटा संग्रहीत करते हैं, तो यह आपके प्रोग्राम को क्रैश करने के लिए या सामान्य रूप से, आपके कंप्यूटर पर कुछ खतरनाक कोड चलाने के लिए, कई तरह से क्षतिग्रस्त या संशोधित हो सकता है। अचार का उपयोग करने के लिए बेहतर:

 import pickle data = {'foo': [1, 2, 3], 'bar': ('Hello', 'world!'), 'baz': True} jar = open('data.pkl', 'wb') pickle.dump(data, jar) #     jar jar.close() 

और अब, कुछ घंटों के बाद, हमें फिर से अपने शब्दकोश की आवश्यकता है:

 import pickle pkl_file = open('data.pkl', 'rb') #  data = pickle.load(pkl_file) #    print data pkl_file.close() 

क्या हुआ?वास्तव में जो अपेक्षित था। dataमानो यह हमेशा रहा हो।

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

स्वयं की वस्तुओं का सीरियलाइजेशन।

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

• __getinitargs__(self)
  यदि आप चाहते हैं कि आपकी कक्षा को डीरियलाइज़ेशन के बाद बुलाया जाए __init__, तो आप यह निर्धारित कर सकते हैं कि __getinitargs__किस तर्क को भेजना चाहिए __init__। ध्यान दें कि यह विधि केवल पुराने-शैली की कक्षाओं के साथ काम करती है।
  
  
• __getnewargs__(self)
  नई-शैली की कक्षाओं के लिए, आप यह निर्धारित कर सकते हैं कि कौन से पैरामीटर __new__डिसेरिएलाइज़ेशन के दौरान पारित किए जाएंगे । इस पद्धति को भी भेजे जाने वाले तर्कों की एक वापसी करनी चाहिए __new__।
  
  
• __getstate__(self)
__dict__ , , . __setstate__ .
  
  
• __setstate__(self, state)
__setstate__ , , __dict__ . __getstate__ : , , .
  
  
• __reduce__(self)
  ( Python's C API), , , . __reduce__() , . , , , . 2 5 : , , , , , __setstate__ (), () ().
  
  
• __reduce_ex__(self, protocol)
  इसे लागू करते समय प्रोटोकॉल संस्करण को जानना कभी-कभी उपयोगी होता है __reduce__। और इसे लागू करने के बजाय प्राप्त किया जा सकता है __reduce_ex__। यदि __reduce_ex__कार्यान्वित किया जाता है, तो कॉल वरीयता इसे दी जाती है (आपको अभी भी इसे __reduce__पिछड़े संगतता के लिए लागू करना चाहिए )।
  
  

उदाहरण

उदाहरण के लिए, हम एक स्लेट बोर्ड ( Slate) का वर्णन करते हैं , जो याद करता है कि उस पर क्या और कब लिखा गया था। हालांकि, विशेष रूप से यह बोर्ड हर बार धारावाहिक रूप से साफ हो जाता है: वर्तमान मूल्य नहीं बचा है।

 import time class Slate: ''',     .      .''' def __init__(self, value): self.value = value self.last_change = time.asctime() self.history = {} def change(self, new_value): #  .     . self.history[self.last_change] = self.value self.value = new_value self.last_change = time.asctime() def print_changes(self): print 'Changelog for Slate object:' for k, v in self.history.items(): print '%s\t %s' % (k, v) def __getstate__(self): #    self.value or self.last_change. #   " "  . return self.history def __setstate__(self, state): self.history = state self.value, self.last_change = None, None 

निष्कर्ष

इस गाइड का उद्देश्य पाइथन या ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के साथ अपने अनुभव की परवाह किए बिना, इसे पढ़ने वाले सभी को कुछ बताना है। यदि आप पायथन में नए हैं, तो आपको कार्यात्मक, सुरुचिपूर्ण, और आसानी से उपयोग होने वाली कक्षाओं के लेखन की मूल बातें के बारे में मूल्यवान ज्ञान प्राप्त हुआ है। यदि आप एक मध्य-स्तरीय प्रोग्रामर हैं, तो आपको कुछ अच्छे नए विचार और रणनीतियाँ मिल सकती हैं, जो आपके और आपके ग्राहकों द्वारा लिखे गए कोड की मात्रा को कम करने के कुछ अच्छे तरीके हैं। यदि आप एक विशेषज्ञ पिटोनिस्ट हैं, तो आपने अपने कुछ संभवतः भूल गए ज्ञान को अपडेट किया है, या शायद कुछ नए ट्रिक पाए हैं। आपके स्तर के बावजूद, मुझे आशा है कि विशेष पायथन विधियों के माध्यम से यह यात्रा वास्तव में जादुई थी (विरोध नहीं कर सकी)।

परिशिष्ट 1: मैजिक मेथड्स को कैसे कॉल करें

जादू के कुछ तरीके सीधे अंतर्निहित कार्यों से संबंधित हैं; इस मामले में, यह काफी स्पष्ट है कि उन्हें कैसे बुलाया जाए। हालांकि, यह हमेशा मामला नहीं होता है। यह ऐड-ऑन एक गैर-स्पष्ट वाक्यविन्यास को प्रकट करने के लिए है, जो जादू के तरीकों की कॉल के लिए अग्रणी है।

जादू की विधि	जब इसे कहा जाता है (उदाहरण)	व्याख्या
__new__(cls [,...])	instance = MyClass(arg1, arg2)	__new__ तात्कालिकता पर आह्वान किया
__init__(self [,...])	instance = MyClass(arg1, arg2)	__init__ तात्कालिकता पर आह्वान किया
__cmp__(self, other)	self == other, self > otherआदि	किसी भी तुलना के लिए कहा जाता है।
__pos__(self)	+self	यूनीरी प्लस साइन
__neg__(self)	-self	एकांत माइनस साइन
__invert__(self)	~self	बिटवाइस उलटा
__index__(self)	x[self]	जब कोई ऑब्जेक्ट इंडेक्स के रूप में उपयोग किया जाता है तो उसे कन्वर्ट करें
__nonzero__(self)	bool(self) । if self:	वस्तु का बूलियन मूल्य
__getattr__(self, name)	self.name # name	कोई भी अचूक विशेषता प्राप्त करने की कोशिश नहीं की जा रही है
__setattr__(self, name, val)	self.name = val	किसी विशेषता का असाइनमेंट
__delattr__(self, name)	del self.name	गुण हटाएं
__getattribute__(self, name)	self.name	कोई विशेषता प्राप्त करें
__getitem__(self, key)	self[key]	एक सूचकांक के माध्यम से एक आइटम प्राप्त करना
__setitem__(self, key, val)	self[key] = val	एक सूचकांक के माध्यम से एक आइटम को सौंपना
__delitem__(self, key)	del self[key]	एक इंडेक्स के माध्यम से किसी वस्तु को निकालना
__iter__(self)	for x in self	यात्रा
__contains__(self, value)	value in self । value not in self	के साथ स्वामित्व का सत्यापन in
__call__(self [,...])	self(args)	"कॉल" उदाहरण
__enter__(self)	with self as x:	with संदर्भ प्रबंधक ऑपरेटर
__exit__(self, exc, val, trace)	with self as x:	with संदर्भ प्रबंधक ऑपरेटर
__getstate__(self)	pickle.dump(pkl_file, self)	क्रमबद्धता
__setstate__(self)	data = pickle.load(pkl_file)	क्रमबद्धता

मुझे उम्मीद है कि यह तालिका आपको जादू के तरीकों को कॉल करने के लिए वाक्यविन्यास के बारे में कोई प्रश्न बचाती है।

अनुपूरक 2: पायथन 3 में परिवर्तन

हम कई मुख्य मामलों का वर्णन करेंगे जब पायथन 3 अपने ऑब्जेक्ट मॉडल के संदर्भ में 2.x से भिन्न होता है:

• के बाद से एक स्ट्रिंग और यूनिकोड के बीच अजगर 3 अंतर चला गया है, __unicode__गायब हो गया, और दिखाई दिया __bytes__(जो की तरह बर्ताव करता है __str__और __unicode__2.7) के निर्माण के लिए नए निर्मित सरणियों बाइट कार्य करता है।
• चूंकि पायथन 3 में विभाजन अब डिफ़ॉल्ट "सही विभाजन" है, और __div__नहीं।
• __coerce__ अधिक नहीं, अतिरेक और अजीब व्यवहार के कारण।
• __cmp__ अतिरेक के कारण नहीं।
• __nonzero__का नाम बदल दिया गया __bool__।
• nextयह iterators पर था नाम बदलकर में __next__।