कुछ पायथन विशेषताएं जिनके बारे में आप नहीं जानते होंगे

प्रस्तावना

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

शर्तों के बारे में थोड़ा

शायद मैं उन शब्दों से शुरू करूँगा जो अक्सर शुरुआत पायथन प्रोग्रामर को भ्रमित करते हैं।

सूची की समझ या सूची जनरेटर एक सूची लौटाते हैं। मैं हमेशा सूची जनरेटर और अभिव्यक्ति जनरेटर (लेकिन अभिव्यक्ति जनरेटर नहीं!) को भ्रमित करता हूं। सहमत हूँ, रूसी में यह बहुत समान लगता है। अभिव्यक्तियाँ - जनरेटर जनरेटर अभिव्यक्तियाँ हैं , विशेष अभिव्यक्तियाँ जो एक पुनरावृत्त लौटाती हैं, सूची नहीं। आइए तुलना करें:

f = (x for x in xrange(100)) #  -  c = [x for x in xrange(100)] #   

ये दो पूरी तरह से अलग डिजाइन हैं। पहला एक जनरेटर (यानी एक पुनरावृत्त) देता है, दूसरा एक सामान्य सूची है।

जनरेटर या जनरेटर विशेष कार्य हैं जो एक पुनरावृत्तिकर्ता को लौटाते हैं। जनरेटर प्राप्त करने के लिए, आपको उपज के माध्यम से फ़ंक्शन मान लौटाना होगा:

 def prime(lst): for i in lst: if i % 2 == 0: yield i >>> f = prime([1,2,3,4,5,6,7]) >>> list(f) [2, 4, 6] >>> next(f) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> 

वैसे, पायथन 3.3 ने निर्माण से एक नई उपज पेश की। उपज साझा करना और इसके लिए उपयोग किया जाता है, ताकि दोनों निर्माण गठबंधन करने का निर्णय लें।

 def generator_range(first, last): for i in xrange(first, last): yield i def generator_range(first, last): yield from range(first, last) 

संदर्भ प्रबंधक क्या हैं और वे किस लिए हैं?

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

 fp = open("./file.txt", "w") fp.write("Hello, World") fp.close() 

हर बार बंद () विधि को कॉल करने से बचने के लिए, हम खुले () फ़ंक्शन के संदर्भ प्रबंधक का उपयोग कर सकते हैं, जो ब्लॉक से बाहर निकलने के बाद फ़ाइल को स्वचालित रूप से बंद कर देगा:

 with open("./file.txt", "w") as fp: fp.write("Hello, World") 

यहां हमें किसी फ़ाइल में डेटा को पुश करने के लिए हर बार करीबी विधि को कॉल करने की आवश्यकता नहीं है। यह निम्नानुसार है कि संदर्भ प्रबंधक का उपयोग ब्लॉक में प्रवेश करने से पहले और बाहर निकलने के बाद किसी भी क्रिया को करने के लिए किया जाता है। लेकिन संदर्भ प्रबंधकों की कार्यक्षमता वहाँ समाप्त नहीं होती है। कई प्रोग्रामिंग भाषाएं ऐसे कार्यों के लिए विध्वंसक का उपयोग करती हैं। लेकिन पायथन में, यदि वस्तु का उपयोग कहीं और किया जाता है, तो इस बात की कोई गारंटी नहीं है कि विध्वंसक को कहा जाएगा, क्योंकि __del__ विधि को केवल तभी कहा जाता है जब वस्तु के सभी संदर्भ समाप्त हो गए हों:

 In [4]: class Hello: ...: def __del__(self): ...: print 'destructor' ...: In [5]: f = Hello() In [6]: c = Hello() In [7]: e = Hello() In [8]: del e destructor In [9]: del c destructor In [10]: c = f In [11]: e = f In [12]: del f # <-    

हम इस समस्या को संदर्भ प्रबंधकों के माध्यम से हल करेंगे:

 In [1]: class Hello: ...: def __del__(self): ...: print u'' ...: def __enter__(self): ...: print u'  ' ...: def __exit__(self, exp_type, exp_value, traceback): ...: print u'  ' ...: In [2]: f = Hello() In [3]: c = f In [4]: e = f In [5]: d = f In [6]: del d In [7]: del e In [8]: del c In [9]: del f # <-            

अब संदर्भ प्रबंधक को कॉल करने का प्रयास करें:

 In [10]: with Hello(): ....: print u' ' ....:          

हमने देखा कि हमारे कोड के निष्पादन के बाद ब्लॉक से बाहर निकलने की गारंटी थी।

प्रसंग प्रबंधक प्रोटोकॉल

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

ब्लॉक के साथ बाहर निकलने के बाद __exit__ पद्धति को निष्पादित किया जाता है, और इसमें तीन पैरामीटर होते हैं - exp_type, exp_value, और exp_tr। संदर्भ प्रबंधक उन अपवादों को पकड़ सकता है जिन्हें ब्लॉक के साथ उठाया गया है। हम केवल उन अपवादों को पकड़ सकते हैं जिनकी हमें आवश्यकता है या अनावश्यक को दबा दें।

 class Open(object): def __init__(self, file, flag): self.file = file self.flag = flag def __enter__(self): try: self.fp = open(self.file, self.flag) except IOError: self.fp = open(self.file, "w") return self.fp def __exit__(self, exp_type, exp_value, exp_tr): """    IOError """ if exp_type is IOError: self.fp.close() #   return True self.fp.close() #   with Open("asd.txt", "w") as fp: fp.write("Hello, World\n") 

चर exp_type में अपवाद वर्ग शामिल था जो उठाया गया था, exp_value अपवाद संदेश है। उदाहरण में, हम फ़ाइल को बंद कर देते हैं और IOError अपवाद को दबा देते हैं, सत्य को __exit__ विधि पर लौटाते हैं। ब्लॉक में अन्य सभी अपवादों की अनुमति है। जैसे ही हमारा कोड समाप्त हो जाता है और ब्लॉक समाप्त हो जाता है, self.fp.close () विधि को कहा जाता है, चाहे जो भी अपवाद उठाया गया हो। वैसे, ब्लॉक के साथ अंदर आप ऐसे अपवादों को दबा सकते हैं जैसे NameError, SyntaxError, लेकिन आपको ऐसा नहीं करना चाहिए।

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

प्रसंगवश पैकेज

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

 import contextlib @contextlib.contextmanager def context(): print u'  ' try: yield {} except RuntimeError, err: print 'error: ', err finally: print u'  ' 

कोड के स्वास्थ्य की जाँच करें:

 In [8]: with context() as fp: ...: print u'' ...:        

चलो ब्लॉक के अंदर एक अपवाद को बढ़ाने की कोशिश करते हैं।

 In [14]: with context() as value: ....: raise RuntimeError, 'Error' ....:    error: Error    In [15]: 

जैसा कि आप उदाहरण से देख सकते हैं, व्यावहारिक रूप से वर्गों के उपयोग से एक कार्यान्वयन संदर्भन () डेकोरेटर का उपयोग करके कार्यान्वयन से भिन्न नहीं होता है, लेकिन डेकोरेटर का उपयोग करना हमारे कोड को बहुत सरल करता है।

प्रसारक () डेकोरेटर का उपयोग करने का एक और दिलचस्प उदाहरण:

 import contextlib @contextlib.contextmanager def bold_text(): print '<b>' yield #    with   print '</b>' with bold_text(): print "Hello, World" 

परिणाम:

 <b>Hello, World</b> 

रूबी में ब्लॉक की तरह लगता है ना?

और अंत में, नेस्टेड संदर्भों के बारे में बात करते हैं। नेस्टेड संदर्भ आपको एक बार में कई संदर्भों का प्रबंधन करने देते हैं। उदाहरण के लिए:

 import contextlib @contextlib.contextmanager def context(name): print u'   %s' % (name) yield name #   print u'   %s' % (name) with contextlib.nested(context('first'), context('second')) as (first, second): print u'  %s %s' % (first, second) 

परिणाम:

पहले संदर्भ दर्ज करना
संदर्भ में प्रवेश दूसरा
पहले दूसरे ब्लॉक के अंदर
संदर्भ से बाहर
पहले संदर्भ से बाहर

नेस्टेड फ़ंक्शन का उपयोग किए बिना समान कोड:

 first, second = context('first'), context('second') with first as first: with second as second: print u'  %s %s' % (first, second) 

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

 with context('first') as first, context('second') as second: print u'  %s %s' % (first, second) 

रेंज और पायथन में 2.7 और पायथन 3 में

पायथन 2.7 रेंज को एक सूची वापस करने के लिए जाना जाता है। मुझे लगता है कि हर कोई इस बात से सहमत होगा कि मेमोरी में बड़ी मात्रा में डेटा स्टोर करना अव्यावहारिक है, इसलिए हम xrange फ़ंक्शन का उपयोग करते हैं, जो एक xrange ऑब्जेक्ट देता है जो लगभग एक सूची के समान व्यवहार करता है, लेकिन मेमोरी में सभी आउटपुट तत्वों को संग्रहीत नहीं करता है। लेकिन पायथन 2.x में xrange के व्यवहार से मैं थोड़ा हैरान था जब बड़े मानों को कार्यों के लिए पारित किया जाता है। आइए एक उदाहरण देखें:

 >>> f = xrange(1000000000000000000000) Traceback (most recent call last): File "<stdin>", line 1, in <module> OverflowError: Python int too large to convert to C long >>> 

पायथन हमें बताता है कि int बहुत लंबा है और इसे C लंबे समय तक परिवर्तित नहीं किया जा सकता है। यह पता चला है कि अजगर 2.x के पूर्णांक पर प्रतिबंध है, हम इसे sys.maxsize कंटेंट को देखकर सत्यापित कर सकते हैं:

 >>> import sys >>> sys.maxsize 9223372036854775807 >>> 

यहाँ यह पूर्णांक का अधिकतम मूल्य है:

 >>> import sys >>> sys.maxsize+1 9223372036854775808L >>> 

पायथन ने बड़े करीने से हमारी संख्या को लंबे इंट में बदल दिया। अगर पायथन 2.x में xrange बड़े मूल्यों के साथ अलग तरह से व्यवहार करता है, तो आश्चर्यचकित न हों।

पायथन 3.3 में, एक पूर्णांक असीम रूप से बड़ा हो सकता है, आइए देखें:

 >>> import sys >>> sys.maxsize 9223372036854775807 >>> range(sys.maxsize+1) range(0, 9223372036854775808) >>> 

लंबे इंट में बदलने के कारण ऐसा नहीं हुआ। यहाँ एक और उदाहरण है:

 >>> import sys >>> sys.maxsize + 1 9223372036854775808 >>> f = sys.maxsize + 1 >>> type(f) <class 'int'> >>> 

पायथन 2.7 में

 >>> import sys >>> type(sys.maxsize + 1) <type 'long'> >>> 

कुछ डिजाइनों का स्पष्ट व्यवहार नहीं

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

 >>> f = [[]] * 3 >>> f[0].append('a') >>> f[1].append('b') >>> f[2].append('c') >>> 

इस निर्माण का परिणाम क्या होगा? एक अप्रशिक्षित डेवलपर परिणाम की रिपोर्ट करेगा: [[] a ’], [b’], [c ’]]। लेकिन वास्तव में हमें मिलता है:

 >>> print f [['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']] >>> 

प्रत्येक सूची में परिणाम क्यों दोहराया गया है? तथ्य यह है कि गुणन ऑपरेटर हमारी सूची के भीतर एक ही सूची में लिंक बनाता है। हमारे उदाहरण में थोड़ा जोड़कर सत्यापित करना आसान है:

 >>> c = [[], [], []] >>> hex(id(c[0])), hex(id(c[1])), hex(id(c[2])) ('0x104ede7e8', '0x104ede7a0', '0x104ede908') >>> >>> hex(id(f[0])), hex(id(f[1])), hex(id(f[2])) ('0x104ede710', '0x104ede710', '0x104ede710') >>> 

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

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

 >>> tmp = {} >>> for i in range(10): ... tmp[i] = lambda: i >>> tmp[0]() 9 >>> tmp[1]() 9 >>> 

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

 >>> tmp = {} >>> for i in range(10): ... tmp[i] = lambda i = i: i >>> tmp[0]() 0 >>> tmp[1]() 1 >>>