पायथन कोड के लिए अनुकूलन युक्तियाँ?

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

युक्ति 1:अंतर्निहित कार्यों के लिए जाएं

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

टिप 2:वेरिएबल को स्वैप करने के लिए पाइथॉन मल्टीपल असाइनमेंट का उपयोग करें

>>> #Instead of using
>>> x, y = y, x
>>> #Use this - which is much faster
>>> temp = x
>>> x = y
>>> y = temp

टिप 3:वैश्विक चर से बचें और यदि संभव हो तो स्थानीय चर का उपयोग करें

वैश्विक चर प्राप्त करने की तुलना में स्थानीय चर प्राप्त करते समय पायथन तेज़ होता है। यानी हो सके तो ग्लोबल वेरिएबल से बचें।

टिप 4:जहां भी संभव हो "इन" का उपयोग करें

सामान्य तौर पर सदस्यता की जांच करने के लिए, "इन" कीवर्ड का उपयोग करें। यह साफ और तेज है।

for key in sequence:
   print ("Hello ", key)

टिप 5:अनंत लूप के लिए "जबकि 1" का उपयोग करें

ऐसे समय होते हैं जब हमें अपने प्रोग्राम में अनंत लूप चलाना पड़ता है (उदाहरण के लिए, एक सुनने वाला सॉकेट)। भले ही "जबकि ट्रू" एक ही ऑपरेशन करेगा, "जबकि 1" सिंगल जंप ऑपरेशन है।

>>> while 1:
   # do something, faster with while 1
>>> while True:
   #do something, perform same operation but slower than then previous one

युक्ति 6:सूची समझ का उपयोग करें

हम कई "के लिए" और "जबकि" ब्लॉक को बदलने के लिए पायथन 2.0 से सूची समझ का उपयोग कर सकते हैं। सूची की समझ बहुत तेज है क्योंकि यह लूपिंग के दौरान एक पूर्वानुमेय पैटर्न को खोजने के लिए पायथन दुभाषिया के लिए अनुकूलित है। यह अधिक पठनीय है और ज्यादातर मामलों में यह गिनती के लिए एक अतिरिक्त चर बचाता है।

उदाहरण के लिए एक पंक्ति से 1 से 25 के बीच सम संख्या ज्ञात करने के लिए:

>>> #Using list comprehension - good way
>>> print([i for i in range (25) if i%2 == 0])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]
>>> # Another way - not so efficient way
i = 0
evens = []

while i< 25:
   if i%2 == 0:
      evens.append(i)
   i += 1

print(evens)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]

टिप 7:मांग पर मूल्य प्राप्त करने के लिए पायथन जनरेटर का उपयोग करें

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

>>> chunkBytes = (1000 * i for i in range(1000))
>>> next(chunkBytes)
0
>>> next(chunkBytes)
1000
>>> next(chunkBytes)
2000
>>> next(chunkBytes)
3000
>>>

टिप 8:itertools मॉड्यूल का उपयोग

itertools मॉड्यूल पुनरावृत्ति और संयोजन के लिए बहुत उपयोगी और कुशल है।

पायथन कोड की कुछ पंक्तियों में [1, 2, 3, 4, 5] सूची के लिए सभी क्रमपरिवर्तन उत्पन्न करने के लिए

>>> import itertools
>>> iter1 = itertools.permutations([1, 2, 3,4])
>>> list(iter1)
[(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]

टिप 9:सूची को क्रमबद्ध क्रम में रखने के लिए द्विभाजित मॉड्यूल का उपयोग

यह एक मुफ़्त बाइनरी खोज कार्यान्वयन है और क्रमबद्ध अनुक्रम के लिए एक तेज़ प्रविष्टि उपकरण है।

>>> import bisect
>>> bisect.insort(list, element)

हमने अपनी सूची में तत्व डाला है और अब हमें कंटेनर को क्रमबद्ध रखने के लिए फिर से सॉर्ट () को कॉल करने की आवश्यकता नहीं है, जो एक लंबे अनुक्रम पर बहुत महंगा हो सकता है।

टिप 10:शब्दकोश का उपयोग और परीक्षण सदस्यता के लिए सेट

शब्दकोश और सेट के रूप में हैश तालिका का उपयोग करके कार्यान्वित किया जाता है, यह जांच कर रहा है कि कोई तत्व किसी शब्दकोश में मौजूद है या सेट पाइथन में बहुत तेज़ है। कभी-कभी लुकअप O(1) जितना तेज़ होता है।

>>> lst = ['a', 'ab', 'abc'] #Slow - Checking membership with list
>>> 'abc' in lst
True
>>> mySet = set(['a', 'ab', 'abc'])# Fast - checking membership with set or dictionary
>>> 'abc' in mySet
True

टिप 11:पाइथॉन डेकोरेटर के साथ कैश परिणाम

पायथन डेकोरेटर प्रतीक "@" है। हम न केवल ट्रेसिंग, लॉकिंग या लॉगिंग के लिए पायथन डेकोरेटर का उपयोग कर सकते हैं, हम इसका उपयोग पायथन फ़ंक्शन को सजाने के लिए कर सकते हैं ताकि यह बाद में आवश्यक परिणामों (याद रखने) को याद रखे।

>>> from functools import wraps
>>> def memo(f):
   cache = {}
   @wraps(f)
   def wrap(*arg):
      if arg not in cache:
         cache['arg'] = f(*arg)
      return cache['arg']
   return wrap

और हम इस डेकोरेटर का उपयोग फिबोनाची फ़ंक्शन पर कर सकते हैं

>>> @memo
def fib(i):
   if i<2:
      return 1
   return fib(i-1) + fib(i-2)

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