पायथन के लिए द्विआधारी मॉड्यूल

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


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

• नेटिव C / C ++ एक्सटेंशन
• बड़ा घूँट
• Cython
• ctypes
• रतुआ

वक्ता के बारे में : दिमित्री ज़िल्त्सोव 10 से अधिक वर्षों से विकसित कर रहा है। वह Cian में एक सिस्टम आर्किटेक्ट के रूप में काम करता है, यानी वह तकनीकी समाधान और समय नियंत्रण के लिए जिम्मेदार है। अपने जीवन में मैं असेंबलर, हास्केल, सी की कोशिश करने में कामयाब रहा, और पिछले 5 वर्षों से मैं पायथन में सक्रिय रूप से प्रोग्रामिंग कर रहा हूं।

कंपनी के बारे में

बहुत से लोग जो मास्को में रहते हैं और किराए के आवास शायद CIAN के बारे में जानते हैं। CYAN प्रति माह 7 मिलियन खरीदार और किरायेदार है। इन सभी उपयोगकर्ताओं को हर महीने, हमारी सेवा का उपयोग करके, रहने के लिए एक जगह मिल जाती है।

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

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

लेख में दो भाग होंगे।

1. मेरा अनुभव: उनकी आवश्यकता क्यों है, जब उनका सबसे अच्छा उपयोग किया जाता है, और जब नहीं।
   
2. उपकरण और प्रौद्योगिकियां जिनके साथ आप पायथन के लिए एक बाइनरी मॉड्यूल लागू कर सकते हैं।
   

बाइनरी मॉड्यूल की आवश्यकता क्यों है?

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

लेकिन पायथन को एक और दर्द है - यह जीआईएल है । उनके बारे में बड़ी संख्या में लेख लिखे गए हैं और उनके आसपास कैसे पहुंचा जाए, इस पर रिपोर्ट बनाई गई है।

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

बहुत से लोग मानते हैं कि बाइनरी एक्सटेंशन का उपयोग करके आप स्रोत कोड छिपा सकते हैं । प्रश्न बहुत ही विवादास्पद है, निश्चित रूप से, कुछ जंगली विकृतियों की मदद से यह हासिल किया जा सकता है, लेकिन इसकी कोई 100% गारंटी नहीं है। अधिकतम जो आप प्राप्त कर सकते हैं वह क्लाइंट को विघटित नहीं होने देना है और देखना है कि आपके द्वारा पारित कोड में क्या होता है।

बाइनरी एक्सटेंशन की वास्तव में आवश्यकता कब होती है?

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

एक्सटेंशन एक्सटेंशन लिखने के लिए, किसी को यह ध्यान रखना चाहिए कि यह, सबसे पहले, लंबा होगा। सबसे पहले आपको अपने एल्गोरिदम को "चाटना" चाहिए, अर्थात्। देखें कि क्या कोई जाम हैं।

90% मामलों में, एल्गोरिथम की गहन जांच के बाद, कुछ एक्सटेंशन लिखने की आवश्यकता गायब हो जाती है।

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

यदि आपको कुछ विशिष्ट प्रोटोकॉल को लागू करने की आवश्यकता है, तो सरल सी / सी ++ कोड बनाने और बहुत दर्द से छुटकारा पाने के लिए सुविधाजनक हो सकता है। मैंने अपने समय में एक टेलीकॉम ऑपरेटर में ऐसा किया था, क्योंकि कोई तैयार पुस्तकालय नहीं था - मुझे इसे स्वयं लिखना था। लेकिन मैं दोहराता हूं, अब यह बहुत प्रासंगिक नहीं है, क्योंकि एसिंको है, और अधिकांश कार्यों के लिए यह पर्याप्त है।

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

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

5 सुनहरे नियम

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

1. केवल निर्यात कार्य । बाइनरी लाइब्रेरी में पाइथन में बिल्डिंग क्लास काफी समय लेने वाली हैं: आपको बहुत सारे इंटरफेस का वर्णन करने की आवश्यकता है, आपको मॉड्यूल में ही बहुत सारे संदर्भ अखंडता की समीक्षा करने की आवश्यकता है। फ़ंक्शन के लिए एक छोटा इंटरफ़ेस लिखना आसान है।
   
2. रैपर कक्षाओं का उपयोग करें । कुछ ओओपी के बहुत शौकीन हैं और वास्तव में कक्षाएं चाहते हैं। किसी भी मामले में, भले ही ये कक्षाएं न हों, केवल पायथन रैपर लिखना बेहतर है: एक क्लास बनाएं, एक क्लास विधि या एक नियमित पद्धति को परिभाषित करें, देशी C / C ++ फ़ंक्शन को कॉल करें। कम से कम, यह डेटा आर्किटेक्चर की अखंडता को बनाए रखने में मदद करता है। यदि आप किसी प्रकार के C / C ++ थर्ड-पार्टी एक्सटेंशन का उपयोग करते हैं जिसे आप ठीक नहीं कर सकते हैं, तो रैपर में आप इसे हैक कर सकते हैं ताकि यह सब काम कर सके।
   
3. आप एक विस्तार से अजगर से तर्क पारित नहीं कर सकते - यह भी एक नियम नहीं है, बल्कि एक आवश्यकता है। कुछ मामलों में, यह काम कर सकता है, लेकिन यह आमतौर पर एक बुरा विचार है। इसलिए, आपके कोड में, आपको पहले एक हैंडलर बनाना होगा जो कि सी को टाइप करने के लिए पायथन टाइप कास्ट करता है और उसके बाद ही किसी भी देशी फ़ंक्शन को कॉल करता है जो पहले से ही टाइप एस के साथ काम करता है। वही हैंडलर एक निष्पादन योग्य फ़ंक्शन से प्रतिक्रिया प्राप्त करता है और इसे पायथन डेटा प्रकारों में बदल देता है, और इसे पायथन कोड में फेंक देता है।
   
4. कचरा संग्रह को ध्यान में रखें । पायथन में एक प्रसिद्ध जीसी है, और आपको इसके बारे में नहीं भूलना चाहिए। उदाहरण के लिए, हम संदर्भ द्वारा पाठ का एक बड़ा टुकड़ा पास करते हैं और पुस्तकालय में कुछ शब्द खोजने की कोशिश करते हैं। हम इसे समानांतर करना चाहते हैं, हम इस मेमोरी क्षेत्र और कई थ्रेड्स के लॉन्च के लिए लिंक पास करते हैं। इस समय, GC केवल लेता है और निर्णय लेता है कि कुछ और इस वस्तु को संदर्भित नहीं करता है और इसे मेमोरी क्षेत्र से हटा देता है। उसी कोड में, हमें केवल एक शून्य संदर्भ मिलता है, और यह आमतौर पर एक विभाजन दोष है। हमें कचरे के संग्रहकर्ता की ऐसी विशेषता के बारे में नहीं भूलना चाहिए और लाइब्रेरियों, चार, पूर्णांक, आदि के लिए सबसे सरल डेटा प्रकार पास करना चाहिए।
   
   दूसरी ओर, जिस भाषा में विस्तार लिखा जाता है, उसका अपना कचरा संग्रहकर्ता हो सकता है। पायथन और सी # लाइब्रेरी का संयोजन इस अर्थ में एक दर्द है।
   
5. निर्यात समारोह के तर्कों को स्पष्ट रूप से परिभाषित करें । इसके द्वारा, मैं कहना चाहता हूं कि इन कार्यों को गुणात्मक रूप से व्याख्या करने की आवश्यकता होगी। यदि हम PyObject फ़ंक्शन को स्वीकार करते हैं, और किसी भी स्थिति में हम इसे अपने पुस्तकालय में स्वीकार करेंगे, तो हमें स्पष्ट रूप से संकेत देना होगा कि कौन से तर्क किस प्रकार के हैं। यह उपयोगी है क्योंकि यदि हम गलत डेटा प्रकार पास करते हैं, तो हमें लाइब्रेरी में एक त्रुटि मिलेगी। यही है, आपको अपनी सुविधा के लिए इसकी आवश्यकता है।
   

बाइनरी एक्सटेंशन आर्किटेक्चर

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

प्रौद्योगिकी और उपकरण

बाइनरी एक्सटेंशन लिखने का सबसे प्रसिद्ध तरीका नेटिव सी / सी ++ एक्सटेंशन है। सिर्फ इसलिए कि यह मानक पायथन तकनीक है।

मूल C / C ++ एक्सटेंशन

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

name = 'DateTime.mxDateTime.mxDateTime' src = 'mxDateTime/mxDateTime.c' extra_compile_args=['-g3', '-o0', '-DDEBUG=2', '-UNDEBUG', '-std=c++11', '-Wall', '-Wextra'] setup ( ... ext_modules = [(name, { 'sources': [src], 'include_dirs': ['mxDateTime'] , extra_compile_args: extra_compile_args } )] ) 

देशी सी / सी ++ एक्सटेंशन के पेशेवरों

• देशी तकनीक।
• यह प्रोजेक्ट असेंबली में आसानी से एकीकृत हो जाता है।
• प्रलेखन की सबसे बड़ी राशि।
• आपको अपने स्वयं के डेटा प्रकार बनाने की अनुमति देता है।

मूल निवासी C / C ++ एक्सटेंशन

• उच्च प्रवेश दहलीज।
• सी। का ज्ञान आवश्यक है।
• Boost.Python।
• खंडन दोष।
• डिबगिंग में कठिनाइयाँ।

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

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

Boost.Python C ++ के लिए बहुत अच्छा है, यह आपको इन सभी रैपरों से लगभग पूरी तरह से अमूर्त करने की अनुमति देता है जिनका उपयोग हम Pyon में करते हैं। लेकिन माइनस, मुझे लगता है, यह है कि आपको इसका कुछ हिस्सा लेने के लिए बहुत पसीना बहाना होगा और पूरे बूस्ट को डाउनलोड किए बिना परियोजना में आयात करना होगा।

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

आइए एक उदाहरण देखें कि हम इसे कैसे बनाते हैं।

 #include <Python.h> static PyObject*addList_add(Pyobject* self, Pyobject* args){ PyObject * listObj; if (! PyARg_Parsetuple( args, "", &listObj)) return NULL; long length = PyList_Size(listObj) int i, sum =0; //   return Py_BuildValue("i", sum); } 

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

इस मामले में, हर कोई समझता है - हम सूची के सभी तत्वों का योग पाते हैं। थोड़ा और आगे चलते हैं।

 for(i = 0; i< length; i++){ //     //   Python- PyObject* temp = PyList_GetItem(listObj, i); //  ,      //     C long long elem= PyLong_AsLong(temp); sum += elem; } 

यह एक ही बात है, इस समय, listObj एक पायथन ऑब्जेक्ट है। और इस मामले में, हम सूची आइटम लेने की कोशिश कर रहे हैं। Python.h के पास इसके लिए आपकी जरूरत की हर चीज है।

हम अस्थायी हो गए, हम इसे लंबे समय तक कास्ट करने की कोशिश करते हैं। और उसके बाद ही आप C में कुछ कर सकते हैं।

 //  static char addList_docs[] = "add( ): add all elements of the list\n"; //    static PyMethodDef addList_funcs[] = { {"add", (PyCFunction)addList_add, METH_VARARGS, addList_docs}, {NULL, NULL, 0, NULL} }; 

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

यह सब घोषित करने के बाद, हम एक मॉड्यूल बनाने की कोशिश करते हैं। हम एक moduledef बनाते हैं और हमने जो कुछ भी किया है, उसे वहां रखा है।

 static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "addList example module", -1, adList_funcs, NULL, NULL, NULL, NULL }; 

PyModuleDef_HEAD_INIT एक मानक पायथन स्थिरांक है जिसे आपको हमेशा उपयोग करना चाहिए। -1 दर्शाता है कि आयात चरण में किसी अतिरिक्त मेमोरी को आवंटित करने की आवश्यकता नहीं है।

जब हमने स्वयं मॉड्यूल बनाया था, तो हमें इसे प्रारंभ करने की आवश्यकता है। अजगर हमेशा init की तलाश में रहता है, इसलिए addList के लिए PyInit_addList बनाएं। अब इकट्ठे ढांचे से, आप PyModule_Create को कॉल कर सकते हैं और अंत में मॉड्यूल खुद बना सकते हैं। अगला, मेटा-जानकारी जोड़ें और मॉड्यूल को स्वयं वापस करें।

 PyInit_addList(void){ PyObject *module = PyModule_Create(&mdef); If (module == NULL) return NULL; PyModule_AddStringConstant(module, "__author__", "Bruse Lee<brus@kf.ch>:"); PyModule_addStringConstant (Module, "__version__", "1.0.0"); return module; } 

जैसा कि आप पहले ही देख चुके हैं, बहुत सारी चीजों को बदलना है। जब हम C / C ++ में लिखते हैं तो आपको हमेशा पायथन को याद रखना चाहिए।

इसीलिए, लगभग 15 साल पहले, एक साधारण नश्वर प्रोग्रामर के जीवन को सुविधाजनक बनाने के लिए, SWIG तकनीक दिखाई दी।

बड़ा घूँट

यह उपकरण आपको पायथन बाइंडिंग से अमूर्त और देशी कोड लिखने की अनुमति देता है। इसमें Native C / C ++ के समान पेशेवरों और विपक्ष हैं, लेकिन अपवाद हैं।

SWIG पेशेवरों:

• स्थिर तकनीक।
• प्रलेखन की एक बड़ी मात्रा।
• बंधन से अजगर तक सार।

SWIG के विपक्ष:

• लंबा सेटअप।
• ज्ञान सी।
• खंडन दोष।
• डिबगिंग में कठिनाइयाँ।
• परियोजना की विधानसभा में एकीकरण की जटिलता।

पहला ऋण यह है कि जब आप इसे सेट करते हैं, तो आप अपना दिमाग खो देंगे । जब मैंने इसे पहली बार सेट किया, तो मैंने इसे लॉन्च करने के लिए एक-डेढ़ दिन बिताया। फिर, ज़ाहिर है, यह आसान है। SWIG 3.x आसान हो गया है।

अब कोड में नहीं जाने के लिए, SWIG की सामान्य योजना पर विचार करें।



example.c एक C मॉड्यूल है जो पायथन के बारे में कुछ भी नहीं जानता है। एक इंटरफ़ेस फ़ाइल example.i है, जो SWIG प्रारूप में वर्णित है। उसके बाद, SWIG उपयोगिता चलाएं, जो इंटरफ़ेस फ़ाइल से example_wrap.c बनाता है - यह वही आवरण है जो हम अपने हाथों से करते थे। यही है, SWIG सिर्फ हमारे लिए एक फ़ाइल आवरण बनाता है, तथाकथित पुल। उसके बाद, जीसीसी का उपयोग करते हुए, हम दो फाइलों को संकलित करते हैं और दो ऑब्जेक्ट फाइलें (उदाहरण.ओ और example_wrap.o) प्राप्त करते हैं और उसके बाद ही हम अपनी लाइब्रेरी बनाते हैं। सब कुछ सरल और स्पष्ट है।

Cython

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

साइथन पेशेवरों:

• लोकप्रिय तकनीक।
• बहुत स्थिर है।
• यह प्रोजेक्ट असेंबली में आसानी से एकीकृत हो जाता है।
• अच्छा प्रलेखन।

साइथन का विपक्ष:

• खुद का सिंटैक्स।
• ज्ञान सी।
• खंडन दोष।
• डिबगिंग में कठिनाइयाँ।

विपक्ष, हमेशा की तरह, है। मुख्य एक इसका अपना सिंटैक्स है, जो C / C ++ के समान है, और पायथन के लिए बहुत अधिक है।

लेकिन मैं यह बताना चाहता हूं कि पायथन कोड को देशी कोड लिखकर साइथन का उपयोग करके त्वरित किया जा सकता है।



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

ctypes

CTypes मानक पायथन लाइब्रेरी है जो फॉरेन फंक्शन इंटरफेस के साथ काम करती है। एफएफआई एक निम्न-स्तरीय पुस्तकालय है। यह एक देशी तकनीक है, इसे अक्सर कोड में उपयोग किया जाता है, इसकी मदद से क्रॉस-प्लेटफॉर्म को लागू करना आसान है।

लेकिन एफएफआई बहुत अधिक ओवरहेड करता है क्योंकि सभी पुलों, रनटाइम में सभी हैंडलर गतिशील रूप से बनाए जाते हैं। यही है, हमने डायनेमिक लाइब्रेरी लोड की है, और इस समय पायथन को पता नहीं है कि लाइब्रेरी क्या है। केवल जब एक पुस्तकालय को स्मृति में बुलाया जाता है, तो ये पुल गतिशील रूप से निर्मित होते हैं।

CTypes के पेशेवरों:

• देशी तकनीक।
• कोड में उपयोग करने के लिए आसान है।
• क्रॉस-प्लेटफॉर्म को लागू करना आसान है।
• आप लगभग किसी भी भाषा का उपयोग कर सकते हैं।

विपक्ष

• ओवरहेड ले जाता है।
• डिबगिंग में कठिनाइयाँ।

 from ctypes import * #load the shared object file Adder = CDLL('./adder.so') #Calculate factorial res_int = adder.fact(4) print("Fact of 4 = " + str(res_int)) 

उन्होंने adder.so लिया और इसे रनटाइम में बुलाया। हम देशी पायथन प्रकारों में भी पास कर सकते हैं।

इस सब के बाद, सवाल यह है: "यह किसी भी तरह से जटिल है, हर जगह सी, क्या करना है?"।

रतुआ

एक समय में, मैंने भाषा को उचित ध्यान नहीं दिया था, लेकिन अब मैं व्यावहारिक रूप से इसे बदल देता हूं।

जंग के पेशेवरों:

• सुरक्षित भाषा।
• सही व्यवहार की शक्तिशाली स्थिर गारंटी।
• आसानी से प्रोजेक्ट बिल्ड ( PyO3 ) में एकीकृत हो जाता है।

जंग की विपक्ष:

• उच्च प्रवेश दहलीज।
• लंबा सेटअप।
• डिबगिंग में कठिनाइयाँ।
• थोड़ा दस्तावेज है।
• कुछ मामलों में, ओवरहेड।

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

PyO3 टीम की बदौलत, Rust के लिए अच्छे Python बाइंडर्स हैं, और प्रोजेक्ट में इंटीग्रेट करने के लिए टूल्स हैं।

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

कोड का एक छोटा सा उदाहरण, वही मॉड्यूल जिसकी हमने पहले जांच की थी।

 #![feature(proc_macro)] #[macro_use] extern crate pyo3; Use pyo3::prelude::*; /// Module documentation string 1 #[py::modinit(_addList)] fn init(py: Python, m: PyModule) -> PyResult <()>{ py_exception!(_addList, EmptyListError); /// Function documentation string 1 #[pufn(m, "run", args= "*", kwargs="**" )] fn run_py(_py: Python, args: &PyTuple, kwargs: Option<&PyDict>) -> PyResult<()> { run(args, kwargs) } #[pyfn(m, "run", args="*", kwatgs="**")] fn run_py(_py: Python, args: &PyTuple, kwargs: Option<&PyDict>) -> PyResult<()>{ run(args,kwargs) } #[pyfn(m,"add")] fn add(_py: Python, py_list: &PyList) -> PyResult<i32>{ let mut sum : i32 = 0 match py_list.len() { /// Some code Ok(sum) } Ok(()) } 

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

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

आइए अधिक विस्तार से देखें कि वह क्या करना शुरू कर रहा है।

 #[pyfn(m, "add", py_list="*")] fn add(_py: Python, py_list: &PyList) -> PyResult<i32> { match py_list.len() { 0 =>Err(EmptyListError::new("List is empty")), _ => { let mut sum : i32 = 0; for item in py_list.iter() { let temp:i32 = match item.extract() { Ok(v) => v, Err(_) => { let err_msg: String = format!("List item {} is not int", item); return Err(ItemListError::new(err_msg)) } }; sum += temp; } Ok(sum) } } } 

समान कोड जो C / C ++ / Ctypes में था, लेकिन केवल Rust में। वहाँ मैंने कुछ समय तक PyObject को कास्ट करने की कोशिश की। यदि हमें सूची में मिला, तो संख्याओं को छोड़कर, क्या हमें एक स्ट्रिंग मिलेगा? हाँ, हमें एक SystemEerror मिलेगा। इस मामले में, लेट म्यूट योग के माध्यम से : i32 = 0; हम सूची से एक मूल्य प्राप्त करने और i32 में डालने का प्रयास कर रहे हैं। यही है, हम इस कोड को आइटम के बिना नहीं लिख पाएंगे। कस्टमर (), अनजाने में और वांछित प्रकार के लिए कास्ट करें। जब हमने संकलित अवस्था में, i32 को Rust त्रुटि के मामले में लिखा है, तो यह कहेगा: "जब i32 नहीं तो केस को हैंडल करें"। इस मामले में, यदि हमारे पास i32 है, तो हम एक मान लौटाते हैं, अगर यह एक त्रुटि है, तो हम एक अपवाद फेंकते हैं।

क्या चुनना है?

इस छोटे दौरे के बाद हम सोचेंगे कि अंत में क्या चुनना है?

जवाब वास्तव में आपके स्वाद और रंग का है।

मैं किसी विशिष्ट तकनीक को बढ़ावा नहीं दूंगा।



बस संक्षेप में कहा गया था:

• SWIG और C / C ++ के मामले में, आपको C / C ++ को अच्छी तरह से जानना होगा, समझें कि इस मॉड्यूल का विकास कुछ अतिरिक्त ओवरहेड को उकसाएगा। लेकिन न्यूनतम उपकरण का उपयोग किया जाएगा, और हम देशी पायथन तकनीक में काम करेंगे, जो डेवलपर्स द्वारा समर्थित है।
• साइथन के मामले में, हमारे पास एक छोटा इनपुट थ्रेशोल्ड है, हमारे पास एक उच्च विकास गति है, और यह भी एक साधारण कोड जनरेटर है।
• CTypes की कीमत पर, मैं आपको अपेक्षाकृत बड़े ओवरहेड के बारे में चेतावनी देना चाहता हूं। डायनेमिक लाइब्रेरी लोड हो रहा है, जब हमें पता नहीं है कि यह किस तरह की लाइब्रेरी है, तो बहुत परेशानी हो सकती है।
• मैं रस्ट को किसी ऐसे व्यक्ति को लेने की सलाह दूंगा जो सी / सी ++ को अच्छी तरह से नहीं जानता है। उत्पादन में जंग वास्तव में कम से कम समस्याओं का वहन करती है।

कागजात के लिए कॉल करें

हम 7 सितंबर तक मॉस्को पायथन कॉन्फ ++ के लिए आवेदन स्वीकार करते हैं - इस सरल रूप में लिखें कि आप पायथन के बारे में जानते हैं जिसे आपको समुदाय के साथ साझा करने की आवश्यकता है।

उन लोगों के लिए जो सुनने में अधिक रुचि रखते हैं, मैं शांत रिपोर्ट के बारे में बात कर सकता हूं।

• डोनाल्ड व्हाईट को पायथन में गणित में तेजी लाने के बारे में बात करना पसंद है और हमारे लिए एक नई कहानी तैयार कर रहा है: लोकप्रिय पुस्तकालयों, ट्रिक्स और कपटीपन का उपयोग करके गणित को 10 गुना तेज कैसे बनाया जाए, और कोड स्पष्ट और समर्थित है।
  
• अर्टिओम मालिशेव ने अपने सभी कई वर्षों के अनुभव को Django के विकास में इकट्ठा किया है और फ्रेमवर्क पर एक रिपोर्ट-गाइड प्रस्तुत कर रहा है! HTTP रिक्वेस्ट प्राप्त करने और तैयार वेब पेज भेजने के बीच जो कुछ भी होता है, वह होता है: एक्सपोज़िंग मैजिक, फ्रेमवर्क के आंतरिक तंत्र का एक नक्शा और आपकी परियोजनाओं के लिए कई उपयोगी टिप्स।