पायथन कोड ऑप्टिमाइज़ेशन टिप्स

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

टिप 1: बिल्ट-इन फंक्शंस का उपयोग करें

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

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

>>> # बजाय इसके
>>> temp = x
>>> x = y
>>> y = temp
>>> # इसका उपयोग करें - जो बहुत तेज़ है
>>> x, y = y, x

टिप 3: ग्लोबल वेरिएबल्स से बचें और संभव हो तो लोकल वेरिएबल्स का उपयोग करें

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

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

सामान्य रूप से मेंबरशिप चेक करने के लिए "in" कीवर्ड का उपयोग करें। यह साफ और तेज़ है।

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

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

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

>>> while 1:
    # do something, faster with while 1
>>> while True:
    # do something, वही ऑपरेशन लेकिन पिछले वाले से धीमा

टिप 6: लिस्ट कॉम्प्रिहेंशन का उपयोग करें

हम पायथन 2.0 से लिस्ट कॉम्प्रिहेंशन का उपयोग करके कई "for" और "while" ब्लॉक्स को बदल सकते हैं। लिस्ट कॉम्प्रिहेंशन बहुत तेज़ है क्योंकि यह पायथन इंटरप्रेटर के लिए लूपिंग के दौरान एक पूर्वानुमानित पैटर्न को पहचानने के लिए ऑप्टिमाइज़्ड है। यह अधिक पठनीय है और ज्यादातर मामलों में काउंटिंग के लिए एक अतिरिक्त वेरिएबल बचाता है।

उदाहरण के लिए, 1 से 25 तक की सम संख्याएं एक लाइन में खोजने के लिए:

>>> # लिस्ट कॉम्प्रिहेंशन का उपयोग - अच्छा तरीका
>>> print([i for i in range(25) if i % 2 == 0])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]
>>> # दूसरा तरीका - इतना कुशल नहीं
>>> 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

टिप 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), ...]

टिप 9: सॉर्टेड ऑर्डर में सूची रखने के लिए bisect मॉड्यूल का उपयोग

यह एक फ्री बाइनरी सर्च इम्प्लीमेंटेशन है और सॉर्टेड सीक्वेंस के लिए फास्ट इंसर्शन टूल है।

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

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

टिप 10: मेंबरशिप टेस्ट के लिए डिक्शनरी और सेट का उपयोग

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

>>> lst = ['a', 'ab', 'abc']  # धीमा - सूची के साथ मेंबरशिप चेक
>>> 'abc' in lst
True
>>> mySet = set(['a', 'ab', 'abc'])  # तेज़ - सेट या डिक्शनरी के साथ मेंबरशिप चेक
>>> '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)

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