किसी कार्य को करते समय यह आवश्यक है जिसमें कई क्रियाओं या डेटा को संसाधित करने की आवश्यकता होती है। इसलिए, कुछ अप्रभावी कोड ब्लॉकों और कार्यात्मकताओं को बदलने और बढ़ाने से निम्नलिखित जैसे आश्चर्यजनक परिणाम हो सकते हैं:
- एप्लिकेशन के प्रदर्शन को बढ़ावा दें
- पठनीय और व्यवस्थित कोड बनाएं
- त्रुटि निगरानी और डिबगिंग को सरल बनाएं
- पर्याप्त कम्प्यूटेशनल शक्ति आदि का संरक्षण करें
अपना कोड प्रोफाइल करें
अनुकूलन शुरू करने से पहले, प्रोजेक्ट कोड के उन हिस्सों की पहचान करना आवश्यक है जो इसे धीमा कर रहे हैं। पायथन में प्रोफाइलिंग की तकनीकों में सीप्रोफाइल और प्रोफाइल पैकेज शामिल हैं। ऐसे टूल का उपयोग यह मापने के लिए करें कि कोड की कुछ फ़ंक्शन और लाइनें कितनी तेज़ी से निष्पादित होती हैं। सीप्रोफ़ाइल मॉड्यूल एक रिपोर्ट तैयार करता है जो बताता है कि प्रत्येक स्क्रिप्ट फ़ंक्शन को चलने में कितना समय लगता है। यह रिपोर्ट हमें धीमी गति से चल रहे किसी भी फ़ंक्शन को ढूंढने में मदद कर सकती है ताकि हम उनमें सुधार कर सकें।
सांकेतिक टुकड़ा:
आयात सीप्रोफ़ाइल जैसा सीपी
डीईएफ़ गणनायोग ( इनपुटनंबर ) :
इनपुट_नंबरों का योग = 0
जबकि इनपुटनंबर > 0 :
sum_of_input_numbers + = इनपुटनंबर % 10
इनपुटनंबर // = 10
छपाई ( 'इनपुट संख्या में सभी अंकों का योग है: 'sum_of_input_numbers'' )
वापस करना इनपुट_नंबरों का योग
डीईएफ़ main_func ( ) :
सी.पी. दौड़ना ( 'गणनायोग(9876543789)' )
अगर __नाम__ == '__मुख्य__' :
main_func ( )
जैसा कि आउटपुट की पहली पंक्ति में देखा गया है, प्रोग्राम कुल पाँच फ़ंक्शन कॉल करता है। प्रत्येक फ़ंक्शन कॉल का विवरण निम्नलिखित कुछ पंक्तियों में दिखाया गया है जिसमें फ़ंक्शन को लागू करने की संख्या, फ़ंक्शन में समय की कुल अवधि, प्रति कॉल समय की अवधि, और फ़ंक्शन में समय की कुल मात्रा (सहित) शामिल है सभी कार्यों को इसे कहा जाता है)।
इसके अतिरिक्त, प्रोग्राम प्रॉम्प्ट स्क्रीन पर एक रिपोर्ट प्रिंट करता है जो दर्शाता है कि प्रोग्राम अपने सभी कार्यों का निष्पादन समय 0.000 सेकंड के भीतर पूरा कर लेता है। इससे पता चलता है कि प्रोग्राम कितना तेज़ है.
सही डेटा संरचना चुनें
प्रदर्शन विशेषताएँ डेटा संरचना पर निर्भर हैं। विशेष रूप से, सामान्य प्रयोजन भंडारण से संबंधित सूचियों की तुलना में शब्दकोश लुकअप के लिए तेज़ होते हैं। यदि आप जानते हैं तो उस डेटा संरचना का चयन करें जो उन परिचालनों के लिए सबसे उपयुक्त है जो हम आपके डेटा पर संचालित करेंगे। निम्नलिखित उदाहरण एक समान प्रक्रिया के लिए विभिन्न डेटा संरचनाओं की प्रभावशीलता की जांच करता है ताकि यह निर्धारित किया जा सके कि डेटा संरचना में कोई तत्व मौजूद है या नहीं।
हम यह जांचने में लगने वाले समय का मूल्यांकन करते हैं कि प्रत्येक डेटा संरचना - एक सूची, एक सेट और एक शब्दकोश - में कोई तत्व मौजूद है या नहीं और उनकी तुलना करते हैं।
ऑप्टिमाइज़डेटाटाइप.py:
आयात मैं समय जैसा टीटीआयात random जैसा rndobj
# पूर्णांकों की एक सूची बनाएं
यादृच्छिक_डेटा_सूची = [ rndobj. randint ( 1 , 10000 ) के लिए _ में श्रेणी ( 10000 ) ]
# उसी डेटा से एक सेट बनाएं
यादृच्छिक_डेटा_सेट = तय करना ( यादृच्छिक_डेटा_सूची )
# कुंजियों के समान डेटा के साथ एक शब्दकोश बनाएं
obj_DataDictionary = { एक पर: कोई नहीं के लिए एक पर में यादृच्छिक_डेटा_सूची }
# खोजने के लिए तत्व (डेटा में मौजूद है)
यादृच्छिक_संख्या_खोजें = rndobj. पसंद ( यादृच्छिक_डेटा_सूची )
# किसी सूची में सदस्यता की जाँच करने के लिए समय मापें
सूची_समय = टी.टी. मैं समय ( लैम्ब्डा : रैंडम_नंबर_टू_फाइंड में यादृच्छिक_डेटा_सूची , संख्या = 1000 )
# एक सेट में सदस्यता की जांच करने के लिए समय मापें
निर्धारित समय = टी.टी. मैं समय ( लैम्ब्डा : रैंडम_नंबर_टू_फाइंड में यादृच्छिक_डेटा_सेट , संख्या = 1000 )
# शब्दकोश में सदस्यता की जांच करने के लिए समय मापें
dict_time = टी.टी. मैं समय ( लैम्ब्डा : रैंडम_नंबर_टू_फाइंड में obj_DataDictionary , संख्या = 1000 )
छपाई ( एफ 'सूची सदस्यता जांच समय: {list_time:.6f} सेकंड' )
छपाई ( एफ 'सदस्यता जाँच समय निर्धारित करें: {set_time:.6f} सेकंड' )
छपाई ( एफ 'शब्दकोश सदस्यता जांच समय: {dict_time:.6f} सेकंड' )
सदस्यता जाँच करते समय यह कोड सूचियों, सेटों और शब्दकोशों के प्रदर्शन की तुलना करता है। सामान्य तौर पर, सेट और शब्दकोश सदस्यता परीक्षणों की सूचियों की तुलना में काफी तेज़ होते हैं क्योंकि वे हैश-आधारित लुकअप का उपयोग करते हैं, इसलिए उनकी औसत समय जटिलता O(1) होती है। दूसरी ओर, सूचियों को रैखिक खोज करनी चाहिए जिसके परिणामस्वरूप O(n) समय जटिलता के साथ सदस्यता परीक्षण होते हैं।
लूप्स के बजाय बिल्ट-इन फ़ंक्शंस का उपयोग करें
फ़िल्टरिंग, सॉर्टिंग और मैपिंग जैसे विशिष्ट कार्यों को करने के लिए पायथन में कई अंतर्निहित कार्यों या विधियों का उपयोग किया जा सकता है। किसी के लूप बनाने के बजाय इन रूटीन का उपयोग करने से कोड को गति देने में मदद मिलती है क्योंकि वे अक्सर प्रदर्शन-अनुकूलित होते हैं।
आइए विशिष्ट नौकरियों (जैसे मानचित्र(), फ़िल्टर(), और सॉर्ट किए गए()) के लिए अंतर्निहित फ़ंक्शंस का उपयोग करके कस्टम लूप बनाने के प्रदर्शन की तुलना करने के लिए कुछ नमूना कोड बनाएं। हम मूल्यांकन करेंगे कि विभिन्न मैपिंग, निस्पंदन और सॉर्टिंग विधियां कितनी अच्छी तरह प्रदर्शन करती हैं।
बिल्टइनफंक्शन्स.py:
आयात मैं समय जैसा टीटी# संख्या_सूची की नमूना सूची
संख्या_सूची = सूची ( श्रेणी ( 1 , 10000 ) )
# लूप का उपयोग करके संख्याओं को वर्गाकार करने का कार्य
डीईएफ़ वर्ग_उपयोग_लूप ( संख्या_सूची ) :
वर्ग_परिणाम = [ ]
के लिए एक पर में नंबर_सूची:
वर्ग_परिणाम. संलग्न ( एक पर ** 2 )
वापस करना वर्ग_परिणाम
# लूप का उपयोग करके सम संख्या_सूची को फ़िल्टर करने का कार्य
डीईएफ़ फ़िल्टर_सम_उपयोग_लूप ( संख्या_सूची ) :
फ़िल्टर_परिणाम = [ ]
के लिए एक पर में नंबर_सूची:
अगर एक पर % 2 == 0 :
फ़िल्टर_परिणाम. संलग्न ( एक पर )
वापस करना फ़िल्टर_परिणाम
# लूप का उपयोग करके संख्याओं_सूची को क्रमबद्ध करने का कार्य
डीईएफ़ सॉर्ट_यूजिंग_लूप ( संख्या_सूची ) :
वापस करना क्रमबद्ध ( संख्या_सूची )
# मानचित्र() का उपयोग करके संख्याओं का वर्ग सूची बनाने में लगने वाले समय को मापें
मानचित्र_समय = टी.टी. मैं समय ( लैम्ब्डा : सूची ( नक्शा ( लैम्ब्डा एक्स: एक्स ** 2 , संख्या_सूची ) ) , संख्या = 1000 )
# फ़िल्टर() का उपयोग करके सम संख्या_सूची को फ़िल्टर करने का समय मापें
फ़िल्टर_समय = टी.टी. मैं समय ( लैम्ब्डा : सूची ( फ़िल्टर ( लैम्ब्डा एक्स: एक्स % 2 == 0 , संख्या_सूची ) ) , संख्या = 1000 )
# sorted() का उपयोग करके संख्याओं_सूची को क्रमबद्ध करने का समय मापें
क्रमबद्ध_समय = टी.टी. मैं समय ( लैम्ब्डा : क्रमबद्ध ( संख्या_सूची ) , संख्या = 1000 )
# एक लूप का उपयोग करके संख्याओं को वर्गांकित करने में लगने वाले समय को मापें
लूप_मैप_टाइम = टी.टी. मैं समय ( लैम्ब्डा : स्क्वायर_यूजिंग_लूप ( संख्या_सूची ) , संख्या = 1000 )
# एक लूप का उपयोग करके सम संख्या_सूची को फ़िल्टर करने का समय मापें
लूप_फ़िल्टर_टाइम = टी.टी. मैं समय ( लैम्ब्डा : फ़िल्टर_सम_उपयोग_लूप ( संख्या_सूची ) , संख्या = 1000 )
# एक लूप का उपयोग करके संख्याओं_सूची को क्रमबद्ध करने का समय मापें
लूप_सॉर्टेड_टाइम = टी.टी. मैं समय ( लैम्ब्डा : सॉर्ट_यूजिंग_लूप ( संख्या_सूची ) , संख्या = 1000 )
छपाई ( 'संख्या सूची में 10000 तत्व हैं' )
छपाई ( एफ 'मानचित्र() समय: {map_time:.6f} सेकंड' )
छपाई ( एफ 'फ़िल्टर() समय: {फ़िल्टर_टाइम:.6f} सेकंड' )
छपाई ( एफ 'सॉर्ट किया गया() समय: {sorted_time:.6f} सेकंड' )
छपाई ( एफ 'लूप (मानचित्र) समय: {loop_map_time:.6f} सेकंड' )
छपाई ( एफ 'लूप (फ़िल्टर) समय: {लूप_फ़िल्टर_टाइम:.6f} सेकंड' )
छपाई ( एफ 'लूप (क्रमबद्ध) समय: {loop_sorted_time:.6f} सेकंड' )
हम संभवतः देखेंगे कि अंतर्निहित फ़ंक्शन (मैप(), फ़िल्टर(), और सॉर्ट किए गए()) इन सामान्य कार्यों के लिए कस्टम लूप से तेज़ हैं। पायथन में अंतर्निहित फ़ंक्शन इन कार्यों को पूरा करने के लिए अधिक संक्षिप्त और समझने योग्य दृष्टिकोण प्रदान करते हैं और प्रदर्शन के लिए अत्यधिक अनुकूलित हैं।
लूप्स को ऑप्टिमाइज़ करें
यदि लूप लिखना आवश्यक है, तो कुछ तकनीकें हैं जिनका उपयोग करके हम उन्हें तेज़ कर सकते हैं। आम तौर पर, रेंज() लूप पीछे की ओर चलने की तुलना में तेज़ होता है। ऐसा इसलिए है क्योंकि रेंज() सूची को उलटे बिना एक पुनरावर्तक उत्पन्न करता है जो लंबी सूचियों के लिए एक महंगा ऑपरेशन हो सकता है। इसके अतिरिक्त, चूंकि रेंज() मेमोरी में एक नई सूची नहीं बनाता है, यह कम मेमोरी का उपयोग करता है।
ऑप्टिमाइज़लूप.py:
आयात मैं समय जैसा टीटी# संख्या_सूची की नमूना सूची
संख्या_सूची = सूची ( श्रेणी ( 1 , 100000 ) )
# सूची को उल्टे क्रम में दोहराने का कार्य
डीईएफ़ लूप_रिवर्स_इटरेशन ( ) :
परिणाम_रिवर्स = [ ]
के लिए जे में श्रेणी ( केवल ( संख्या_सूची ) - 1 , - 1 , - 1 ) :
परिणाम_रिवर्स. संलग्न ( संख्या_सूची [ जे ] )
वापस करना परिणाम_रिवर्स
# रेंज() का उपयोग करके सूची को पुनरावृत्त करने का कार्य
डीईएफ़ लूप_रेंज_इटरेशन ( ) :
परिणाम_श्रेणी = [ ]
के लिए क में श्रेणी ( केवल ( संख्या_सूची ) ) :
परिणाम_श्रेणी. संलग्न ( संख्या_सूची [ क ] )
वापस करना परिणाम_श्रेणी
# रिवर्स पुनरावृत्ति करने में लगने वाले समय को मापें
रिवर्स_टाइम = टी.टी. मैं समय ( लूप_रिवर्स_इटरेशन , संख्या = 1000 )
# रेंज पुनरावृत्ति करने में लगने वाले समय को मापें
रेंज_समय = टी.टी. मैं समय ( लूप_रेंज_इटरेशन , संख्या = 1000 )
छपाई ( 'संख्या सूची में 100000 रिकॉर्ड हैं' )
छपाई ( एफ 'रिवर्स पुनरावृत्ति समय: {रिवर्स_टाइम:.6f} सेकंड' )
छपाई ( एफ 'रेंज पुनरावृत्ति समय: {रेंज_टाइम:.6f} सेकंड' )
अनावश्यक फ़ंक्शन कॉल से बचें
हर बार किसी फ़ंक्शन को कॉल करने पर कुछ ओवरहेड होता है। यदि अनावश्यक फ़ंक्शन कॉल से बचा जाए तो कोड अधिक तेज़ी से चलता है। उदाहरण के लिए, किसी मान की गणना करने वाले फ़ंक्शन को बार-बार निष्पादित करने के बजाय, गणना के परिणाम को एक चर में संग्रहीत करने और उसका उपयोग करने का प्रयास करें।
प्रोफाइलिंग के लिए उपकरण
आपके कोड के प्रदर्शन के बारे में अधिक जानने के लिए, अंतर्निहित प्रोफाइलिंग के अलावा, हम cProfile, Pyflame, या SnapViz जैसे बाहरी प्रोफाइलिंग पैकेज का उपयोग कर सकते हैं।
कैश परिणाम
यदि हमारे कोड को महंगी गणना करने की आवश्यकता है, तो हम समय बचाने के लिए परिणामों को कैशिंग करने पर विचार कर सकते हैं।
कोड रीफैक्टरिंग
कोड को पढ़ने और बनाए रखने में आसान बनाने के लिए उसे दोबारा तैयार करना कभी-कभी इसे अनुकूलित करने का एक आवश्यक हिस्सा होता है। एक तेज़ प्रोग्राम साफ़-सुथरा भी हो सकता है।
जस्ट-इन-टाइम कंपाइलेशन (JIT) का उपयोग करें
PyPy या Numba जैसी लाइब्रेरी एक JIT संकलन प्रदान कर सकती हैं जो कुछ प्रकार के Python कोड को काफी तेज़ कर सकती है।
पायथन को अपग्रेड करें
सुनिश्चित करें कि आप पायथन के नवीनतम संस्करण का उपयोग कर रहे हैं क्योंकि नए संस्करणों में अक्सर प्रदर्शन सुधार शामिल होते हैं।
समांतरता और समवर्तीता
उन प्रक्रियाओं के लिए जिन्हें समानांतर किया जा सकता है, मल्टीप्रोसेसिंग, थ्रेडिंग, या एसिंकियो जैसी समानांतर और सिंक्रनाइज़ेशन तकनीकों की जांच करें।
याद रखें कि बेंचमार्किंग और प्रोफाइलिंग अनुकूलन के मुख्य चालक होने चाहिए। हमारे कोड के उन क्षेत्रों को बेहतर बनाने पर ध्यान केंद्रित करें जिनका प्रदर्शन पर सबसे महत्वपूर्ण प्रभाव पड़ता है, और यह सुनिश्चित करने के लिए अपने सुधारों का लगातार परीक्षण करें कि अधिक दोष उत्पन्न किए बिना उनका वांछित प्रभाव हो।
निष्कर्ष
निष्कर्ष में, बेहतर प्रदर्शन और संसाधन प्रभावशीलता के लिए पायथन कोड अनुकूलन महत्वपूर्ण है। डेवलपर्स विभिन्न तकनीकों का उपयोग करके अपने पायथन अनुप्रयोगों के निष्पादन और प्रतिक्रिया की गति को काफी बढ़ा सकते हैं जैसे कि उपयुक्त डेटा संरचनाओं का चयन करना, अंतर्निहित कार्यों का लाभ उठाना, अतिरिक्त लूप को कम करना और मेमोरी को प्रभावी ढंग से प्रबंधित करना। निरंतर बेंचमार्किंग और प्रोफाइलिंग को अनुकूलन प्रयासों को निर्देशित करना चाहिए, यह सुनिश्चित करते हुए कि कोड की प्रगति वास्तविक दुनिया की प्रदर्शन आवश्यकताओं से मेल खाती है। दीर्घकालिक परियोजना की सफलता की गारंटी देने और नई समस्याओं को पेश करने की संभावना को कम करने के लिए, कोड अनुकूलन को कोड पठनीयता और रखरखाव के उद्देश्यों के साथ लगातार संतुलित किया जाना चाहिए।