पाइथन के लिए पोर्टिंग 3. बग पर काम करना

अनुवादक से नोट:
मैं आपके लिए फ्लास्क और वेर्केजग वेब फ्रेमवर्क, जिंजा 2 टेम्पलेट इंजन के लेखक, और आमतौर पर प्रसिद्ध अजगर के बारे में एक दिलचस्प लेख का अनुवाद प्रस्तुत करता हूं, जो तीसरे पायथन के लिए समर्थन जोड़ते समय अपनी परियोजनाओं में उनके लिए इस्तेमाल की जाने वाली वर्तमान तकनीकों और नुकसानों के बारे में प्रसिद्ध है। इस लेख के शीर्षक के बारे में एक संक्षिप्त टिप्पणी। यह आर्मिन के 2010 के लेख "पोर्टिंग टू पाइथन 3. ए गाइड" का एक संदर्भ है, जिसमें उन्होंने 2to3 उपयोगिता के माध्यम से स्वचालित पोर्टिंग के लिए कोड तैयार करने का वर्णन किया है। जैसा कि अभ्यास से पता चलता है, आज यह दृष्टिकोण एंटीपैटर्न होने की अधिक संभावना है, जैसा कि एक ओर, इस तरह के संचालन के परिणामस्वरूप कोड की गुणवत्ता काफ़ी बिगड़ती है, और इसके अलावा, इस तरह के कोड को बनाए रखना अधिक कठिन होता है।

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

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

इस परिणाम से प्रेरित होकर, मैं कई बार कोड के माध्यम से गया और संयुक्त कोड आधार के साथ आगे प्रयोग करने के लिए कुछ अन्य कोड का अनुवाद करना शुरू किया।

इस लेख में, मैं कुछ युक्तियों और तरकीबों की समीक्षा करूँगा, जिन्हें मैं समान स्थितियों में किसी की मदद करने के मामले में साझा कर सकता हूँ।

समर्थन 2.5, 3.1 और 3.2 को बाहर फेंक दें

यह सबसे महत्वपूर्ण सुझावों में से एक है। अजगर 2.5 का समर्थन करने से इनकार करना आज की तुलना में अधिक है क्योंकि बहुत से लोग इसका उपयोग नहीं कर रहे हैं। 3.1 और 3.2 की अस्वीकृति एक काफी सरल समाधान है, तीसरे पायथन की कम लोकप्रियता को देखते हुए। लेकिन इन संस्करणों का समर्थन करने से इनकार करने का क्या मतलब है? संक्षेप में, 2.6 और 3.3 में ओवरलैपिंग सिंटैक्स और क्षमताओं की एक बड़ी संख्या होती है जो समान कोड को दोनों मामलों में सामान्य रूप से काम करने की अनुमति देते हैं:

• संगत स्ट्रिंग शाब्दिक। 2.6 और 3.3 तार के समान सिंटैक्स का समर्थन करते हैं। आप मूल स्ट्रिंग प्रकारों के लिए 'foo' (2.x में बाइट स्ट्रिंग्स और 3.x में यूनिकोड स्ट्रिंग्स), और u'foo' को यूनिकोड स्ट्रिंग्स और b'foo' लिए बाइट स्ट्रिंग्स या बाइट ऑब्जेक्ट्स दोनों के लिए उपयोग कर सकते हैं।
• संगत print सिंटैक्स। यदि आप from __future__ import print_function उपयोग करते हैं, तो आप एक आवरण फ़ंक्शन का उपयोग करने और अन्य असंगतताओं से पीड़ित होने के बिना, from __future__ import print_function जोड़ सकते हैं और print को फ़ंक्शन के रूप में उपयोग कर सकते हैं।
• संगत कब्जा वाक्यविन्यास। Python 2.6 एक्स के except Exception as e एक नया वाक्यविन्यास पेश करता है, जिसका उपयोग 3.x में किया जाता है।
• वर्ग सज्जाकार उपलब्ध हैं। वे वर्ग संरचना पर निशान छोड़ने के बिना स्वचालित रूप से स्थानांतरित इंटरफेस को सही करने के लिए बेहद उपयोगी हैं। उदाहरण के लिए, वे अजगर __unicode__ में __next__ , या __next__ से __next__ next एक विधि नाम को स्वचालित रूप से नाम बदलने में मदद कर सकते हैं।
• अंतर्निहित फ़ंक्शन next() next या __next__ को कॉल करने के लिए। सुविधाजनक, क्योंकि यह एक सीधी विधि कॉल के समान गति के बारे में काम करता है, इसलिए आपको रनटाइम चेक की तुलना में या अपने स्वयं के आवरण फ़ंक्शन को जोड़ने के लिए प्रदर्शन का भुगतान नहीं करना होगा।
• पायथन 2.6 में, 3.3 के रूप में एक ही इंटरफ़ेस के साथ एक नया bytearray प्रकार जोड़ा गया था। यह उपयोगी है क्योंकि जबकि अजगर 2.6 में bytes ऑब्जेक्ट का अभाव है, इसमें एक अंतर्निहित ऑब्जेक्ट है, जिसका एक ही नाम है, जो str का पर्याय है और पूरी तरह से अलग व्यवहार करता है।
• पायथन 3.3 में, बाइट्स से बाइट्स तक और लाइनों से लाइनों के अनुवाद के लिए कोड 3.1 और 3.2 में टूट गए थे। दुर्भाग्य से, उनके इंटरफेस अधिक जटिल हो गए हैं और कोई उपनाम नहीं हैं, लेकिन यह सब पहले के मुकाबले 2.x में बहुत करीब है। यह विशेष रूप से महत्वपूर्ण है यदि आपको स्ट्रीम-आधारित कोडिंग की आवश्यकता है। यह कार्यक्षमता 3.0 से 3.3 तक पूरी तरह अनुपस्थित थी।

हां, छह मॉड्यूल आपको आगे बढ़ने में मदद करेंगे, लेकिन स्वच्छ कोड देखने में सक्षम होने के लाभों को कम न समझें। मैं कॉरी ने तीसरे पायथन जिनजा 2 को समर्थन देने में रुचि खो दी, क्योंकि मैं उसके कोड से भयभीत था। उस समय, संयुक्त कोड बदसूरत लग रहा था और प्रदर्शन के मामले में पड़ा (लगातार six.b('foo') और six.u('foo') ), या इसकी कम गति 2to3 थी। अब, यह सब निपटा कर, मैं फिर से आनंद लेता हूं। Jinja2 कोड बहुत साफ दिखता है और आपको अजगर 2 और 3 संस्करणों के लिए अनुकूलता समर्थन खोजने के लिए खोजना होगा। if PY2: की शैली में कुछ ही कोड के कुछ टुकड़े करते हैं if PY2:

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

छह को छोड़ दो

छह एक बहुत साफ-सुथरी लाइब्रेरी है और जिंजा 2 ने इसकी शुरुआत की। लेकिन अंत में, यदि आप गिनती करते हैं, तो छह के पास तीसरे पायथन के तहत एक बंदरगाह शुरू करने के लिए इतनी आवश्यक चीजें नहीं होंगी। यदि आप पायथन 2.5 का समर्थन करना चाहते हैं, तो निश्चित रूप से छह आवश्यक है, लेकिन 2.6 और अधिक के साथ शुरू होने पर, छह का उपयोग करने के कई कारण नहीं हैं। Jinja2 में _compat मॉड्यूल है, जिसमें कुछ आवश्यक सहायक हैं। पायथन 3 में नहीं कई पंक्तियों को शामिल करते हुए, संपूर्ण संगतता मॉड्यूल में कोड की 80 से कम लाइनें शामिल हैं।

यह आपको समस्याओं से बचने में मदद करेगा जब उपयोगकर्ता एक अलग पुस्तकालय के कारण पैकेज छह के एक अलग संस्करण की उम्मीद करते हैं या अपनी परियोजना के लिए एक अलग निर्भरता जोड़ते हैं।

शुरुआत आधुनिकीकरण से करें

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

अपने परीक्षण सही करें

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

एक संगतता मॉड्यूल लिखें

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

 import sys PY2 = sys.version_info[0] == 2 if not PY2: text_type = str string_types = (str,) unichr = chr else: text_type = unicode string_types = (str, unicode) unichr = unichr 

इस मॉड्यूल का कोड इस बात पर निर्भर करेगा कि आपके लिए कितना बदलाव आया है। जिनजा 2 के मामले में, मैंने वहां कई कार्य किए। उदाहरण के लिए, itilools से ifilter, imap और इसी तरह के अन्य कार्य हैं जो 3.x में मानक पुस्तकालय का हिस्सा बन गए हैं (मैं 2.x से फ़ंक्शन नामों का उपयोग करता हूं ताकि पाठक को यह स्पष्ट हो सके कि पुनरावृत्तियों का उपयोग करना जानबूझकर नहीं है और त्रुटि नहीं है )।

2.x के लिए जांचें, 3.x नहीं

कुछ बिंदु पर, आपको यह जांचना होगा कि कोड अजगर के 2.x या 3.x संस्करण में चल रहा है या नहीं। इस मामले में, मैं आपको सलाह दूंगा कि आप पहले दूसरे संस्करण की जाँच करें, और दूसरे संस्करण में चेक को दूसरी शाखा में रखें, और न कि कोका। इस मामले में, आपको कम अप्रिय आश्चर्य होगा जब अजगर का 4 वां संस्करण दिखाई देगा।

अच्छा:

 if PY2: def __str__(self): return self.__unicode__().encode('utf-8') 

इतना सही नहीं:

 if not PY3: def __str__(self): return self.__unicode__().encode('utf-8') 

लाइन प्रसंस्करण

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

• 'foo' हमेशा मतलब होता है जिसे मैं एक देशी स्ट्रिंग कार्यान्वयन कहता हूं। ये ऐसे तार हैं जो पहचानकर्ता, स्रोत कोड, फ़ाइल नाम और अन्य निम्न-स्तरीय कार्यों में उपयोग किए जाते हैं। इसके अलावा, 2.x में यूनिकोड स्ट्रिंग्स को शाब्दिक के रूप में उपयोग करने की अनुमति है, लेकिन केवल अगर वे केवल ASCII वर्ण होते हैं।
  
  यह सुविधा एकल कोड आधार के लिए बहुत उपयोगी है, जैसा कि तीसरे पायथन में सामान्य प्रवृत्ति उन इंटरफेस में यूनिकोड समर्थन को जोड़ना है जो पहले इसका समर्थन नहीं करते थे, और इसके विपरीत कभी नहीं। चूंकि देशी स्ट्रिंग शाब्दिक यूनिकोड को "अपग्रेड" करते हैं, लेकिन फिर भी 2.x में यूनिकोड का समर्थन करते हैं, इसलिए वे बहुत उपयोगी हो सकते हैं।
  
  उदाहरण के लिए, फ़ंक्शन datetime.strftime पायथन 2 में यूनिकोड का समर्थन नहीं करता है, लेकिन यह केवल तीसरे संस्करण में यूनिकोड है। चूंकि ज्यादातर मामलों में 2.x में वापसी मूल्य विशेष रूप से ASCII में था, इसलिए ऐसी चीजें 2.x और 3.x दोनों में काम करेंगी:
  

   >>> u'<p>Current time: %s' % datetime.datetime.utcnow().strftime('%H:%M') u'<p>Current time: 23:52' 

  
  strftime दिया गया स्ट्रिंग मूल है (2.x में बाइट्स, 3.x में यूनिकोड)। वापसी मूल्य फिर से एक देशी स्ट्रिंग और विशेष रूप से ASCII में है। नतीजतन, एक ठीक से स्वरूपित यूनिकोड स्ट्रिंग को 2.x और 3.x दोनों में वापस किया जाएगा।
• u'foo' अर्थ हमेशा एक यूनिकोड स्ट्रिंग होता है। बड़ी संख्या में पुस्तकालय पहले से ही 2.x में यूनिकोड का पूरी तरह से समर्थन करते हैं, इसलिए यूनिकोड शाब्दिक किसी के लिए भी आश्चर्य की बात नहीं होगी।
• b'foo' हमेशा मतलब होता है कि वह वास्तविक बाइट को स्टोर करना जानता है। चूँकि 2.6 में वास्तव में bytes ऑब्जेक्ट नहीं है, अजगर 3.3 के विपरीत, जिसमें वास्तविक बाइट लाइनों की कमी होती है, इस शाब्दिक की उपयोगिता कुछ हद तक सीमित है। लेकिन यह फिर से उपयोगी हो जाता है यदि आप इसे bytearray ऑब्जेक्ट के साथ मिलकर उपयोग करते हैं, जिसमें 2.x और 3.x में समान इंटरफ़ेस है:
  

   >>> bytearray(b' foo ').strip() bytearray(b'foo') 

  
  चूंकि यह म्यूट है, बाइट्स के साथ सीधे काम करने के चरण में, आप इसे कुछ और परिचित में बदल सकते हैं, परिणाम को bytes() में फिर से लपेटते हुए bytes() ।
  

इन सरल नियमों के अतिरिक्त, मैंने चर भी जोड़े: text_type , unichr और string_types को मेरे अनुकूलता मॉड्यूल में, जैसा कि ऊपर दिखाया गया है। परिणामस्वरूप, निम्न परिवर्तन होते हैं:

• isinstance(x, basestring) isinstance(x, string_types) बन जाता है isinstance(x, string_types)
• isinstance(x, unicode) isinstance(x, text_type) बन जाता है isinstance(x, text_type)
• isinstance(x, str) यदि बाइट्स को संसाधित करना आवश्यक है, तो यह isinstance(x, bytes) , या isinstance(x, (bytes, bytearray))

मैंने क्लास डेकोरेटर __unicode__ भी लिखा है जो __unicode__ या __unicode__ साथ कक्षाएं लागू करने में मदद करता है:

 if PY2: def implements_to_string(cls): cls.__unicode__ = cls.__str__ cls.__str__ = lambda x: x.__unicode__().encode('utf-8') return cls else: implements_to_string = lambda x: x 

मुख्य विचार 2.x और 3.x दोनों में __str__ पद्धति को लागू करना है, जिससे यह यूनिकोड स्ट्रिंग्स को वापस करने की अनुमति देता है (हाँ, यह 2.x में कुछ भद्दा दिखता है), और डेकोरेटर स्वतः ही इसका नाम बदलकर __unicode__ से 2.x कर देगा। , और __unicode__ जोड़ें जो __unicode__ कॉल __unicode__ और utf-8 को इसकी कॉल का परिणाम __unicode__ । 2.x के लिए मॉड्यूल में हाल ही में यह दृष्टिकोण काफी व्यापक रहा है। तो उदाहरण के लिए करना Jinja2 या Django।

यहाँ एक उदाहरण है:

 @implements_to_string class User(object): def __init__(self, username): self.username = username def __str__(self): return self.username 

मेटाक्लास सिंटेक्स परिवर्तन

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

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

यहाँ यह कैसा दिखता है:

 def with_metaclass(meta, *bases): class metaclass(meta): __call__ = type.__call__ __init__ = type.__init__ def __new__(cls, name, this_bases, d): if this_bases is None: return type.__new__(cls, name, (), d) return meta(name, bases, d) return metaclass('temporary_class', None, {}) And here is how you use it: class BaseForm(object): pass class FormType(type): pass class Form(with_metaclass(FormType, BaseForm)): pass 

शब्दकोशों

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

keys() एक दृश्य ऑब्जेक्ट देता है जो एक अपरिवर्तनीय सेट की तरह व्यवहार करता है, values() एक पुनरावृत्ति कंटेनर को रीड-ओनली क्षमता (लेकिन इट्रेटर नहीं!) और items() एक अपरिवर्तनीय सेट के समान देता है। नियमित सेट के विपरीत, वे उत्परिवर्तित वस्तुओं को भी इंगित कर सकते हैं, जिस स्थिति में कार्यक्रम चल रहा है तो कुछ तरीके गिर सकते हैं।

इस तथ्य के बावजूद कि बड़ी संख्या में लोग इस बिंदु को याद करते हैं कि ऑब्जेक्ट ऑब्जेक्ट पुनरावृत्त नहीं हैं, ज्यादातर मामलों में आप इसे अनदेखा कर सकते हैं। Werkzeug और Django अपनी खुद की शब्दकोश जैसी कई वस्तुओं को लागू करते हैं, और दोनों ही मामलों में समाधान केवल वस्तुओं के अस्तित्व को अनदेखा करना था और keys() और उसके दोस्तों को पुनरावृत्तियों को वापस keys() देना था।

फिलहाल, यह एकमात्र उचित समाधान है, जो उन सीमाओं को ध्यान में रखते हुए है जो अजगर दुभाषिया लगाता है। इसके साथ समस्याएं हैं:

• तथ्य यह है कि वस्तुओं को देखने से प्रति व्यक्ति पुनरावृत्तियों नहीं हैं इसका मतलब है कि आप बिना किसी विशेष कारण के अस्थायी वस्तुओं का निर्माण करते हैं।
• अंतर्निहित शब्दकोश दृश्य के सेट के समान व्यवहार, दुभाषिया सीमाओं के कारण शुद्ध अजगर में वस्तुओं को पुन: पेश नहीं किया जा सकता है
• 3.x के लिए दृश्य वस्तुओं को लागू करने और 2.x के लिए पुनरावृत्तियों कोड पुनरावृत्ति का एक बहुत मतलब होगा।

यहाँ है क्या जिनजा 2 शब्दकोशों पर चलने के मामले में रहता है:

 if PY2: iterkeys = lambda d: d.iterkeys() itervalues = lambda d: d.itervalues() iteritems = lambda d: d.iteritems() else: iterkeys = lambda d: iter(d.keys()) itervalues = lambda d: iter(d.values()) iteritems = lambda d: iter(d.items()) 

शब्दकोशों जैसी वस्तुओं को लागू करने के लिए, क्लास डेकोरेटर हमें फिर से मदद करता है:

 if PY2: def implements_dict_iteration(cls): cls.iterkeys = cls.keys cls.itervalues = cls.values cls.iteritems = cls.items cls.keys = lambda x: list(x.iterkeys()) cls.values = lambda x: list(x.itervalues()) cls.items = lambda x: list(x.iteritems()) return cls else: implements_dict_iteration = lambda x: x 

इस मामले में, आपको बस इतना करना है कि keys() पद्धति और उसके मित्रों को पुनरावृत्तियों के रूप में लागू करें, बाकी सब कुछ अपने आप हो जाएगा।

 @implements_dict_iteration class MyDict(object): ... def keys(self): for key, value in iteritems(self): yield key def values(self): for key, value in iteritems(self): yield value def items(self): ... 

सामान्य इटरेटर परिवर्तन

चूंकि पुनरावृत्तियों ने मूल रूप से बदल दिया है, स्थिति को ठीक करने के लिए कुछ सहायकों की आवश्यकता है। वास्तव में, एकमात्र परिवर्तन next() से __next__ तक संक्रमण था। सौभाग्य से, यह पहले से ही पारदर्शी रूप से संचालित है। केवल एक चीज जो आपको करने की ज़रूरत है वह next(x) पर x.next() को ठीक करना है, और अजगर बाकी की देखभाल करेगा।

यदि आप पुनरावृत्तियों को घोषित करने की योजना बनाते हैं, तो फिर से, एक क्लास डेकोरेटर मदद करेगा:

 if PY2: def implements_iterator(cls): cls.next = cls.__next__ del cls.__next__ return cls else: implements_iterator = lambda x: x 

कक्षा को कार्यान्वित करने के लिए, बस अगले पुनरावृत्ति कदम की विधि को नाम __next__ :

 @implements_iterator class UppercasingIterator(object): def __init__(self, iterable): self._iter = iter(iterable) def __iter__(self): return self def __next__(self): return next(self._iter).upper() 

कोडेक्स बदलें

दूसरे अजगर में एन्कोडिंग प्रोटोकॉल की महान विशेषताओं में से एक इसकी प्रकार की स्वतंत्रता थी। आप एक एन्कोडिंग को पंजीकृत कर सकते हैं जो कि यदि आवश्यक हो तो सीएसवी फ़ाइल को एक सुव्यवस्थित सरणी में अनुवाद करेगा। यह संभावना, हालांकि, बहुत अच्छी तरह से ज्ञात नहीं थी, क्योंकि प्रदर्शनों के दौरान, स्ट्रिंग एन्कोडिंग मुख्य एन्कोडिंग इंटरफ़ेस थे। 3.x से शुरू करके वे अधिक सख्त हो गए, इसलिए अधिकांश कार्यक्षमता को 3.0 संस्करण में हटा दिया गया, और 3.3 पर वापस आ गया, क्योंकि इसके लायक साबित हुआ। सीधे शब्दों में कहें, तो कोडेक्स जो यूनिकोड और बाइट्स के बीच सांकेतिक शब्दों में बदलना नहीं होगा, 3.3 तक उपलब्ध नहीं थे। उनमें से, उदाहरण के लिए, हेक्स और बेस 64 कोडेक्स।

इन कोडेक्स का उपयोग करने के दो उदाहरण यहां दिए गए हैं: लाइन ऑपरेशन और डेटा स्ट्रीम ऑपरेशन। 2.x से अच्छा पुराना str.encode() अब str.encode() कर दिया गया है। यदि आप बदलते एपीआई स्ट्रिंग को देखते हुए 2.x और 3.x का समर्थन करना चाहते हैं:

 >>> import codecs >>> codecs.encode(b'Hey!', 'base64_codec') 'SGV5IQ==\n' 

आप यह भी देखेंगे कि 3.3 में कोडेक्स ने उपनाम खो दिया है, और आपको 'base64' बजाय स्पष्ट रूप से 'base64_codec' लिखना होगा।

इन कोडेक्स का उपयोग करना Binacsii मॉड्यूल के कार्यों का उपयोग करने के लिए बेहतर है, क्योंकि वे वृद्धिशील एन्कोडिंग और डिकोडिंग के लिए समर्थन के माध्यम से डेटा धाराओं पर संचालन का समर्थन करते हैं ।

अन्य नोट

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

• फ़ाइल सिस्टम और फ़ाइल IO एक्सेस लिनक्स पर परेशान हो रहा है, क्योंकि यह यूनिकोड पर आधारित नहीं है। open() फ़ंक्शन और फ़ाइल सिस्टम स्तर में खतरनाक डिफ़ॉल्ट सेटिंग्स हो सकती हैं। यदि, उदाहरण के लिए, मैं SSH के ऊपर एक मशीन से en_US लोकेल के साथ एक मशीन से जाता de_AT , अजगर को फाइल सिस्टम के साथ काम करने और फ़ाइल संचालन के लिए ASCII एन्कोडिंग पर स्विच करना पसंद है।
  
  सामान्य मामले में, मैं तीसरे पायथन में पाठ के साथ काम करने के लिए सबसे विश्वसनीय तरीका मानता हूं, जो 2.x में भी ठीक काम करता है - बस बाइनरी मोड में फाइलें खोलें और स्पष्ट रूप से डिकोड करें। वैकल्पिक रूप से, आप 2.x में codecs.open या io.open उपयोग कर सकते हैं और एक स्पष्ट एन्कोडिंग के साथ 3.x में अंतर्निहित open ।
• मानक लाइब्रेरी में URL को यूनिकोड के रूप में गलत तरीके से प्रदर्शित किया जाता है, जो 3.x में कुछ URL के सामान्य उपयोग में हस्तक्षेप कर सकता है।
• ट्रेसबैक ऑब्जेक्ट के साथ निष्पादन की अस्वीकृति के बाद से एक सहायक फ़ंक्शन की आवश्यकता होती है वाक्यविन्यास को बदल दिया गया है। यह, सामान्य रूप से, एक बहुत ही सामान्य समस्या नहीं है और एक रैपर द्वारा आसानी से हल किया जाता है। क्योंकि वाक्य-विन्यास बदल गया है, यहाँ आपको कोड को क्रियान्वित ब्लॉक के अंदर रखना है:
  

   if PY2: exec('def reraise(tp, value, tb):\n raise tp, value, tb') else: def reraise(tp, value, tb): raise value.with_traceback(tb) 

  
  
• यदि आपके पास कोड है जो वाक्यविन्यास निर्भर है तो पिछला exec हैक उपयोगी है। लेकिन चूंकि निष्पादन का सिंटैक्स स्वयं बदल गया है, अब आपके पास मनमाने नाम वाले किसी भी चीज़ को कॉल करने का कोई तरीका नहीं है। यह कोई बड़ी समस्या नहीं है, क्योंकि eval और compile को एक प्रतिस्थापन के रूप में उपयोग किया जा सकता है जो दोनों संस्करणों में काम करता है। आप कार्य exec_ घोषणा भी कर सकते हैं।
  

   exec_ = lambda s, *a: eval(compile(s, '<string>', 'exec'), *a) 

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

निष्कर्ष

2.x और 3.x के लिए एक एकल कोड आज काफी संभव है। , , , API . , , 2.5, 3.0-3.2, .