5 पायथन विशेषताएं जिनके बारे में मुझे पता नहीं था - लेकिन व्यर्थ

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



यहां तक ​​कि अगर आप एक प्रोग्रामर हैं जो सी की तरह किसी अन्य भाषा से अजगर पर स्विच कर रहे हैं, या यदि आप एक वैज्ञानिक हैं जो MATLAB में काम करते थे, तो उच्च-स्तरीय अमूर्त का उपयोग करके पायथन प्रोग्रामिंग निश्चित रूप से एक बहुत ही विशेष अनुभव है। मैं पांच बहुत महत्वपूर्ण बात करना चाहता हूं, मेरी राय में, पायथन में ऐसी विशेषताएं हैं जो मैं, दुर्भाग्य से, पहले नहीं जानता था।

1. सूची समावेश - एक कॉम्पैक्ट कोड लिखना

कई ऐसे पायथन तंत्रों को lambda , map और बहुत ही रहस्यों को छानते हैं जो प्रत्येक नौसिखिया प्रोग्रामर को सीखना चाहिए। और यद्यपि मुझे यकीन है कि यह सब जानने लायक है, ज्यादातर स्थितियों में जिनमें ये उपकरण लागू किए जा सकते हैं, मैंने इन उपकरणों के अपर्याप्त लचीलेपन का सामना किया है। नतीजतन, वे जितना उपयोगी लग सकते हैं, उससे दूर हैं।

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

 add_func = lambda z: z ** 2 is_odd = lambda z: z%2 == 1 multiply = lambda x,y: x*y aList = list(range(10)) print(aList) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

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

यहाँ सूची समावेश के लिए वाक्य रचना है:

 [ expression(x) for x in aList if optional_condition(x) ] 

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

 print(list(map(add_func, aList))) print([x ** 2 for x in aList]) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] print(list(filter(is_odd, aList))) print([x for x in aList if x%2 == 1]) # [1, 3, 5, 7, 9] # [1, 3, 5, 7, 9] 

2. सूचियों के साथ काम करें - परिपत्र सूची

पायथन आपको सूचियों के साथ काम करते समय नकारात्मक अनुक्रमित का उपयोग करने की अनुमति देता है। निम्नलिखित तुलना सत्य है:

 aList[-1] == aList[len(aList)-1] 

यह संभव बनाता है, उदाहरण के लिए, aList[-2] निर्माण का उपयोग करके सूची के अंत से दूसरा तत्व प्राप्त करना। इसी तरह के अन्य डिजाइन संभव हैं।

इसके अलावा, आप सूची का एक टुकड़ा प्राप्त कर सकते हैं:

 aList[start:end:step] 

यहां, सूची का प्रारंभिक तत्व परिणामी स्लाइस में शामिल है, और अंतिम तत्व इसमें शामिल नहीं है। मान लीजिए कि सूची इस प्रकार है:

 aList = [1, 2, 3, 4, 5, 6, 7, 8, 9] 

aList[2:5] स्लाइस की तरह दिखेगा [2, 3, 4] । इसके अलावा, आप सूची का उपयोग कर "फ्लिप" कर सकते हैं aList[::-1] कमांड। हमारे मामले में, यह [9, 8, 7, 6, 5, 4, 3, 2, 1] will, will [9, 8, 7, 6, 5, 4, 3, 2, 1] । मुझे यह समाधान सूची के "फ्लिप" कार्य के लिए बहुत ही दृश्य और सफल लगता है।

आप इसमें संग्रहीत मूल्यों को अलग-अलग चर में रखकर सूची को अनपैक भी कर सकते हैं। या - अलग-अलग चर और नई सूचियों में अपने मूल्यों को "विघटित" करते हुए एक तारांकन का उपयोग करते हुए:

 a, b, c, d = aList[0:4] print(f'a = {a}, b = {b}, c = {c}, d = {d}') # a = 0, b = 1, c = 2, d = 3 a, *b, c, d = aList print(f'a = {a}, b = {b}, c = {c}, d = {d}') # a = 0, b = [1, 2, 3, 4, 5, 6, 7], c = 8, d = 9 

3. ज़िप और गणना कार्य - छोरों के लिए शक्तिशाली बनाना

zip फ़ंक्शन एक इटेटर बनाता है जो कई सूचियों के तत्वों को जोड़ता है। यह छोरों और समानांतर छंटाई के for सूचियों के समानांतर रेंगने की अनुमति देता है। आप * ऑपरेटर का उपयोग करके संयुक्त तत्वों को उनकी सामान्य स्थिति में लौटा सकते हैं।

यहाँ zip फ़ंक्शन के साथ काम करने का एक उदाहरण दिया गया है:

 numList = [0, 1, 2] engList = ['zero', 'one', 'two'] espList = ['cero', 'uno', 'dos'] print(list(zip(numList, engList, espList))) # [(0, 'zero', 'cero'), (1, 'one', 'uno'), (2, 'two', 'dos')] for num, eng, esp in zip(numList, engList, espList):    print(f'{num} is {eng} in English and {esp} in Spanish.') # 0 is zero in English and cero in Spanish. # 1 is one in English and uno in Spanish. # 2 is two in English and dos in Spanish. 

लेकिन यहाँ सूचियों को उनकी सामान्य स्थिति में कैसे लौटाया जाए:

 Eng = list(zip(engList, espList, numList)) Eng.sort() #   engList a, b, c = zip(*Eng) print(a) print(b) print(c) # ('one', 'two', 'zero') # ('uno', 'dos', 'cero') # (1, 2, 0) 

पहली नज़र में enumerate फ़ंक्शन बहुत जटिल लग सकता है, लेकिन यदि आप इससे निपटते हैं, तो यह पता चलता है कि यह कई मामलों में उपयोगी हो सकता है। यह एक स्वचालित काउंटर है जिसका उपयोग अक्सर लूप के for किया जाता है। इसके अलावा, ऐसे चक्रों में counter = 0 और counter += 1 जैसे निर्माणों का उपयोग करके एक काउंटर चर बनाना और बढ़ाना आवश्यक नहीं है।

लूप के for निर्माण में उपयोग किए जाने वाले दो सबसे शक्तिशाली उपकरण zip और enumerate कार्य हैं:

 upperCase = ['A', 'B', 'C', 'D', 'E', 'F'] lowerCase = ['a', 'b', 'c', 'd', 'e', 'f'] for i, (upper, lower) in enumerate(zip(upperCase, lowerCase), 1):    print(f'{i}: {upper} and {lower}.') # 1: A and a. # 2: B and b. # 3: C and c. # 4: D and d. # 5: E and e. # 6: F and f. 

4. जनरेटर - स्मृति का कुशल उपयोग

जनरेटर का उपयोग ऐसे मामलों में किया जाता है जब कुछ गणनाओं को करना आवश्यक होता है जो परिणामों के एक बड़े समूह की उपस्थिति का कारण बनता है, लेकिन साथ ही ऐसे सभी परिणामों को संग्रहीत करने के लिए स्मृति के एक साथ आवंटन से बचने के लिए आवश्यक है। दूसरे शब्दों में, जनरेटर कुछ निश्चित मान देता है, जैसा कि वे कहते हैं, "मक्खी पर"। हालांकि, वे स्मृति में उन मूल्यों को संग्रहीत नहीं करते हैं जो पहले उनके द्वारा पाए गए थे। नतीजतन, मेमोरी का उपयोग संयम से किया जाता है।

जनरेटर का उपयोग अक्सर बड़ी फ़ाइलों को पढ़ने या yield कीवर्ड का उपयोग करके अनंत अनुक्रम बनाने के लिए किया जाता है। मैं अक्सर अपने शोध परियोजनाओं में उनका उपयोग करना उचित समझता हूं।

 def gen(n):  #     ,   >= n    while True:        yield n        n += 1       G = gen(3)   #   3 print(next(G)) # 3 print(next(G)) # 4 print(next(G)) # 5 print(next(G)) # 6 

5. आभासी वातावरण - कोड अलगाव

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

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

वर्चुअल वातावरण को एक दूसरे से अलग करने के लिए, आप यह कर सकते हैं:

 conda create -n venv pip python=3.7 #   python source activate venv ... source deactivate 

परिणाम

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

प्रिय पाठकों! यदि आप एक नौसिखिया प्रोग्रामर को सिर्फ एक पायथन सुविधा बता सकते हैं, तो आप क्या चुनेंगे?