பல செயல்கள் அல்லது தரவைச் செயலாக்க வேண்டிய பணியைச் செய்யும்போது இது அவசியம். எனவே, சில பயனற்ற குறியீடு தொகுதிகள் மற்றும் செயல்பாடுகளை மாற்றுவது மற்றும் மேம்படுத்துவது பின்வருபவை போன்ற அற்புதமான முடிவுகளைப் பெறலாம்:
- பயன்பாட்டின் செயல்திறனை அதிகரிக்கவும்
- படிக்கக்கூடிய மற்றும் ஒழுங்கமைக்கப்பட்ட குறியீட்டை உருவாக்கவும்
- பிழை கண்காணிப்பு மற்றும் பிழைத்திருத்தத்தை எளிதாக்குங்கள்
- கணிசமான கணக்கீட்டு சக்தி மற்றும் பலவற்றை சேமிக்கவும்
உங்கள் குறியீட்டை சுயவிவரப்படுத்தவும்
மேம்படுத்தத் தொடங்கும் முன், திட்டக் குறியீட்டின் வேகத்தைக் குறைக்கும் பகுதிகளைக் கண்டறிவது அவசியம். பைத்தானில் விவரக்குறிப்புக்கான நுட்பங்களில் cProfile மற்றும் சுயவிவர தொகுப்புகள் அடங்கும். குறியீட்டின் சில செயல்பாடுகள் மற்றும் வரிகள் எவ்வளவு விரைவாகச் செயல்படுகின்றன என்பதை அறிய, அத்தகைய கருவிகளைப் பயன்படுத்தவும். cProfile தொகுதி ஒவ்வொரு ஸ்கிரிப்ட் செயல்பாடும் எவ்வளவு நேரம் இயங்கும் என்பதை விவரிக்கும் அறிக்கையை உருவாக்குகிறது. மெதுவாக இயங்கும் செயல்பாடுகளைக் கண்டறிய இந்த அறிக்கை எங்களுக்கு உதவும், அதனால் அவற்றை மேம்படுத்த முடியும்.
குறியீடு துணுக்கு:
இறக்குமதி cProfile என cP
def கணக்கிடும் தொகை ( உள்ளீடு எண் ) :
உள்ளீடு_எண்களின்_தொகை = 0
போது உள்ளீடு எண் > 0 :
உள்ளீடு_எண்களின் தொகை + = உள்ளீடு எண் % 10
உள்ளீடு எண் // = 10
அச்சு ( 'உள்ளீட்டு எண்ணில் உள்ள அனைத்து இலக்கங்களின் கூட்டுத்தொகை: 'sum_of_input_numbers'' )
திரும்ப உள்ளீடு_எண்களின்_தொகை
def முக்கிய_பங்கு ( ) :
cP. ஓடு ( 'கணக்குத்தொகை(9876543789)' )
என்றால் __பெயர்__ == '__முக்கிய__' :
முக்கிய_பங்கு ( )
நிரல் வெளியீட்டின் முதல் வரியில் காணப்படுவது போல் மொத்தம் ஐந்து செயல்பாட்டு அழைப்புகளை செய்கிறது. ஒவ்வொரு செயல்பாட்டு அழைப்பின் விவரங்களும் பின்வரும் சில வரிகளில் காட்டப்பட்டுள்ளன, இதில் செயல்பாடு எத்தனை முறை செயல்படுத்தப்பட்டது, செயல்பாட்டின் ஒட்டுமொத்த கால அளவு, ஒரு அழைப்புக்கான நேரத்தின் காலம் மற்றும் செயல்பாட்டின் மொத்த நேரம் (உட்பட இது அழைக்கப்படும் அனைத்து செயல்பாடுகளும்).
கூடுதலாக, நிரல் ப்ராம்ட் திரையில் ஒரு அறிக்கையை அச்சிடுகிறது, இது நிரல் அதன் அனைத்து பணிகளையும் 0.000 வினாடிகளுக்குள் செயல்படுத்தும் நேரத்தைக் காட்டுகிறது. நிரல் எவ்வளவு வேகமானது என்பதை இது காட்டுகிறது.
சரியான தரவு கட்டமைப்பைத் தேர்ந்தெடுக்கவும்
செயல்திறன் பண்புகள் தரவு கட்டமைப்பைப் பொறுத்தது. குறிப்பாக, பொது-பயன்பாட்டு சேமிப்பகம் தொடர்பான பட்டியல்களை விட, தேடுதல்களுக்கு அகராதிகள் விரைவானவை. உங்களுக்குத் தெரிந்தால், உங்கள் தரவுகளில் நாங்கள் நடத்தும் செயல்பாடுகளுக்கு மிகவும் பொருத்தமான தரவுக் கட்டமைப்பைத் தேர்ந்தெடுக்கவும். தரவு கட்டமைப்பில் ஒரு உறுப்பு உள்ளதா என்பதைத் தீர்மானிக்க ஒரே மாதிரியான செயல்முறைக்கு வெவ்வேறு தரவு கட்டமைப்புகளின் செயல்திறனை பின்வரும் எடுத்துக்காட்டு ஆராய்கிறது.
ஒவ்வொரு தரவுக் கட்டமைப்பிலும் ஒரு உறுப்பு இருக்கிறதா என்பதைச் சரிபார்ப்பதற்கு எடுக்கும் நேரத்தை மதிப்பீடு செய்கிறோம்—ஒரு பட்டியல், ஒரு தொகுப்பு மற்றும் ஒரு அகராதி—அவற்றை ஒப்பிட்டுப் பார்க்கிறோம்.
OptimizeDataType.py:
இறக்குமதி டைமி என ttஇறக்குமதி சீரற்ற என rndobj
# முழு எண்களின் பட்டியலை உருவாக்கவும்
random_data_list = [ rndobj. ரேண்டிண்ட் ( 1 , 10000 ) க்கான _ உள்ளே சரகம் ( 10000 ) ]
# அதே தரவிலிருந்து ஒரு தொகுப்பை உருவாக்கவும்
சீரற்ற_தரவு_தொகுப்பு = அமைக்கப்பட்டது ( random_data_list )
# விசைகளின் அதே தரவுகளுடன் அகராதியை உருவாக்கவும்
obj_DataDictionary = { ஒன்றில்: இல்லை க்கான ஒன்றில் உள்ளே random_data_list }
தேட வேண்டிய # உறுப்பு (தரவில் உள்ளது)
ரேண்டம்_எண் = rndobj. தேர்வு ( random_data_list )
# பட்டியலில் உறுப்பினரைச் சரிபார்க்க நேரத்தை அளவிடவும்
பட்டியல்_நேரம் = tt டைமி ( லாம்ப்டா : ரேண்டம்_எண் உள்ளே random_data_list , எண் = 1000 )
# ஒரு தொகுப்பில் உறுப்பினரை சரிபார்க்க நேரத்தை அளவிடவும்
நேரம்_செட் = tt டைமி ( லாம்ப்டா : ரேண்டம்_எண் உள்ளே சீரற்ற_தரவு_தொகுப்பு , எண் = 1000 )
# அகராதியில் உறுப்பினரைச் சரிபார்க்க நேரத்தை அளவிடவும்
கட்டளை_நேரம் = tt டைமி ( லாம்ப்டா : random_number_to_find உள்ளே obj_DataDictionary , எண் = 1000 )
அச்சு ( f 'பட்டியலுக்கான உறுப்பினர் சோதனை நேரம்: {list_time:.6f} வினாடிகள்' )
அச்சு ( f 'உறுப்பினர் சரிபார்ப்பு நேரத்தை அமை: {set_time:.6f} வினாடிகள்' )
அச்சு ( f 'அகராதி உறுப்பினர் சோதனை நேரம்: {dict_time:.6f} வினாடிகள்' )
இந்தக் குறியீடு, உறுப்பினர் சோதனைகளைச் செய்யும்போது பட்டியல்கள், தொகுப்புகள் மற்றும் அகராதிகளின் செயல்திறனை ஒப்பிடுகிறது. பொதுவாக, தொகுப்புகள் மற்றும் அகராதிகள் உறுப்பினர் சோதனைகளுக்கான பட்டியலை விட கணிசமாக வேகமானவை, ஏனெனில் அவை ஹாஷ்-அடிப்படையிலான தேடல்களைப் பயன்படுத்துகின்றன, எனவே அவை O(1) இன் சராசரி நேர சிக்கலைக் கொண்டுள்ளன. மறுபுறம், பட்டியல்கள் நேரியல் தேடல்களைச் செய்ய வேண்டும், இது O(n) நேர சிக்கலுடன் உறுப்பினர் சோதனைகளில் விளைகிறது.
லூப்களுக்குப் பதிலாக உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்தவும்
பைத்தானில் உள்ள பல உள்ளமைக்கப்பட்ட செயல்பாடுகள் அல்லது முறைகள் வடிகட்டுதல், வரிசைப்படுத்துதல் மற்றும் மேப்பிங் போன்ற வழக்கமான பணிகளைச் செய்ய பயன்படுத்தப்படலாம். ஒருவரின் சுழல்களை உருவாக்குவதை விட இந்த நடைமுறைகளைப் பயன்படுத்துவது குறியீட்டை விரைவுபடுத்த உதவுகிறது, ஏனெனில் அவை அடிக்கடி செயல்திறன்-உகந்ததாக இருக்கும்.
வழக்கமான வேலைகளுக்கு (வரைபடம்(), வடிகட்டி(), மற்றும் வரிசைப்படுத்தப்பட்ட() போன்ற உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்தி தனிப்பயன் சுழல்களை உருவாக்கும் செயல்திறனை ஒப்பிட்டுப் பார்க்க சில மாதிரிக் குறியீட்டை உருவாக்குவோம். பல்வேறு மேப்பிங், வடிகட்டுதல் மற்றும் வரிசைப்படுத்தும் முறைகள் எவ்வளவு சிறப்பாகச் செயல்படுகின்றன என்பதை மதிப்பீடு செய்வோம்.
BuiltInFunctions.py:
இறக்குமதி டைமி என tt# எண்களின்_பட்டியல் மாதிரி பட்டியல்
எண்கள்_பட்டியல் = பட்டியல் ( சரகம் ( 1 , 10000 ) )
# லூப்பைப் பயன்படுத்தி சதுர எண்களின்_பட்டியலுக்கான செயல்பாடு
def சதுரம்_பயன்படுத்தும்_லூப் ( எண்கள்_பட்டியல் ) :
சதுர_முடிவு = [ ]
க்கான ஒன்றில் உள்ளே எண்கள்_பட்டியல்:
சதுர_முடிவு. இணைக்கவும் ( ஒன்றில் ** 2 )
திரும்ப சதுர_முடிவு
# லூப்பைப் பயன்படுத்தி இரட்டை எண்களின்_பட்டியலை வடிகட்டுவதற்கான செயல்பாடு
def வடிகட்டி_கூட_பயன்படுத்தும்_லூப் ( எண்கள்_பட்டியல் ) :
வடிகட்டி_முடிவு = [ ]
க்கான ஒன்றில் உள்ளே எண்கள்_பட்டியல்:
என்றால் ஒரு% இல் 2 == 0 :
வடிகட்டி_முடிவு. இணைக்கவும் ( ஒன்றில் )
திரும்ப வடிகட்டி_முடிவு
# லூப்பைப் பயன்படுத்தி எண்களின்_பட்டியலை வரிசைப்படுத்துவதற்கான செயல்பாடு
def லூப்பைப்_பயன்படுத்தி வரிசைப்படுத்து ( எண்கள்_பட்டியல் ) :
திரும்ப வரிசைப்படுத்தப்பட்டது ( எண்கள்_பட்டியல் )
# வரைபடத்தைப் பயன்படுத்தி சதுர எண்களின்_பட்டியலுக்கான நேரத்தை அளவிடவும்
வரைபடம்_நேரம் = tt டைமி ( லாம்ப்டா : பட்டியல் ( வரைபடம் ( லாம்ப்டா x: x ** 2 , எண்கள்_பட்டியல் ) ) , எண் = 1000 )
# வடிப்பானைப் பயன்படுத்தி இரட்டை எண்களின்_பட்டியலை வடிகட்டுவதற்கான நேரத்தை அளவிடவும்
வடிகட்டி_நேரம் = tt டைமி ( லாம்ப்டா : பட்டியல் ( வடிகட்டி ( லாம்ப்டா x: x % 2 == 0 , எண்கள்_பட்டியல் ) ) , எண் = 1000 )
# வரிசைப்படுத்தப்பட்ட()ஐப் பயன்படுத்தி எண்களை_பட்டியலிடுவதற்கான நேரத்தை அளவிடவும்
வரிசைப்படுத்தப்பட்ட_நேரம் = tt டைமி ( லாம்ப்டா : வரிசைப்படுத்தப்பட்டது ( எண்கள்_பட்டியல் ) , எண் = 1000 )
# லூப்பைப் பயன்படுத்தி சதுர எண்களின்_பட்டியலுக்கான நேரத்தை அளவிடவும்
loop_map_time = tt டைமி ( லாம்ப்டா : சதுரம்_பயன்படுத்தும்_லூப் ( எண்கள்_பட்டியல் ) , எண் = 1000 )
# லூப்பைப் பயன்படுத்தி இரட்டை எண்களின்_பட்டியலை வடிகட்டுவதற்கான நேரத்தை அளவிடவும்
loop_filter_time = tt டைமி ( லாம்ப்டா : filter_even_using_loop ( எண்கள்_பட்டியல் ) , எண் = 1000 )
# லூப்பைப் பயன்படுத்தி எண்களின்_பட்டியலை வரிசைப்படுத்துவதற்கான நேரத்தை அளவிடவும்
வளைய_வரிசைப்படுத்தப்பட்ட_நேரம் = tt டைமி ( லாம்ப்டா : லூப்பைப்_பயன்படுத்தி வரிசைப்படுத்து ( எண்கள்_பட்டியல் ) , எண் = 1000 )
அச்சு ( 'எண் பட்டியலில் 10000 கூறுகள் உள்ளன' )
அச்சு ( f 'வரைபடம்() நேரம்: {map_time:.6f} வினாடிகள்' )
அச்சு ( f 'வடிகட்டி() நேரம்: {filter_time:.6f} வினாடிகள்' )
அச்சு ( f 'வரிசைப்படுத்தப்பட்ட() நேரம்: {sorted_time:.6f} வினாடிகள்' )
அச்சு ( f 'லூப் (வரைபடம்) நேரம்: {loop_map_time:.6f} வினாடிகள்' )
அச்சு ( f 'லூப் (வடிகட்டி) நேரம்: {loop_filter_time:.6f} வினாடிகள்' )
அச்சு ( f 'லூப் (வரிசைப்படுத்தப்பட்டது) நேரம்: {loop_sorted_time:.6f} வினாடிகள்' )
இந்த பொதுவான பணிகளுக்கான தனிப்பயன் சுழல்களை விட உள்ளமைக்கப்பட்ட செயல்பாடுகள் (வரைபடம்(), வடிகட்டி(), மற்றும் வரிசைப்படுத்தப்பட்ட()) வேகமானவை என்பதை நாங்கள் அவதானிப்போம். பைத்தானில் உள்ள உள்ளமைக்கப்பட்ட செயல்பாடுகள் இந்த பணிகளைச் செய்வதற்கு மிகவும் சுருக்கமான மற்றும் புரிந்துகொள்ளக்கூடிய அணுகுமுறையை வழங்குகின்றன மற்றும் செயல்திறனுக்காக மிகவும் உகந்ததாக இருக்கும்.
சுழல்களை மேம்படுத்தவும்
லூப்களை எழுதுவது அவசியமானால், அவற்றை விரைவுபடுத்த நாம் செய்யக்கூடிய சில நுட்பங்கள் உள்ளன. பொதுவாக, வரம்பு() லூப் பின்தங்கியதை விட வேகமாக இருக்கும். ஏனென்றால், ரேஞ்ச்() பட்டியலைத் தலைகீழாக மாற்றாமல் ஒரு இடிரேட்டரை உருவாக்குகிறது, இது நீண்ட பட்டியல்களுக்கு விலையுயர்ந்த செயல்பாடாக இருக்கலாம். கூடுதலாக, வரம்பு() நினைவகத்தில் புதிய பட்டியலை உருவாக்காததால், இது குறைந்த நினைவகத்தைப் பயன்படுத்துகிறது.
OptimizeLoop.py:
இறக்குமதி டைமி என tt# எண்களின்_பட்டியல் மாதிரி பட்டியல்
எண்கள்_பட்டியல் = பட்டியல் ( சரகம் ( 1 , 100000 ) )
# தலைகீழ் வரிசையில் பட்டியலின் மீது மீண்டும் செயல்படும் செயல்பாடு
def வளைய_தலைகீழ்_மறுபடி ( ) :
முடிவு_தலைகீழ் = [ ]
க்கான ஜே உள்ளே சரகம் ( மட்டுமே ( எண்கள்_பட்டியல் ) - 1 , - 1 , - 1 ) :
முடிவு_தலைகீழ். இணைக்கவும் ( எண்கள்_பட்டியல் [ ஜே ] )
திரும்ப முடிவு_தலைகீழ்
# வரம்பைப் பயன்படுத்தி பட்டியலில் மீண்டும் மீண்டும் செய்யும் செயல்பாடு
def loop_range_iteration ( ) :
முடிவு_வரம்பு = [ ]
க்கான கே உள்ளே சரகம் ( மட்டுமே ( எண்கள்_பட்டியல் ) ) :
முடிவு_வரம்பு. இணைக்கவும் ( எண்கள்_பட்டியல் [ கே ] )
திரும்ப முடிவு_வரம்பு
# தலைகீழ் மறு செய்கையைச் செய்ய எடுக்கும் நேரத்தை அளவிடவும்
தலைகீழ்_நேரம் = tt டைமி ( வளைய_தலைகீழ்_மறுபடி , எண் = 1000 )
# வரம்பு மறு செய்கையைச் செய்ய எடுக்கும் நேரத்தை அளவிடவும்
வரம்பு_நேரம் = tt டைமி ( loop_range_iteration , எண் = 1000 )
அச்சு ( 'எண் பட்டியலில் 100000 பதிவுகள் உள்ளன' )
அச்சு ( f 'தலைகீழ் மறு செய்கை நேரம்: {reverse_time:.6f} வினாடிகள்' )
அச்சு ( f 'வரம்பு மறு செய்கை நேரம்: {range_time:.6f} வினாடிகள்' )
தேவையற்ற செயல்பாடு அழைப்புகளைத் தவிர்க்கவும்
ஒரு செயல்பாடு அழைக்கப்படும் ஒவ்வொரு முறையும் சில மேல்நிலை உள்ளது. தேவையற்ற செயல்பாடு அழைப்புகள் தவிர்க்கப்பட்டால் குறியீடு விரைவாக இயங்கும். எடுத்துக்காட்டாக, மதிப்பைக் கணக்கிடும் செயல்பாட்டை மீண்டும் மீண்டும் செயல்படுத்துவதற்குப் பதிலாக, கணக்கீட்டின் முடிவை மாறியில் சேமித்து அதைப் பயன்படுத்த முயற்சிக்கவும்.
விவரக்குறிப்புக்கான கருவிகள்
உங்கள் குறியீட்டின் செயல்திறனைப் பற்றி மேலும் அறிய, உள்ளமைக்கப்பட்ட விவரக்குறிப்புடன் கூடுதலாக, cProfile, Pyflame அல்லது SnakeViz போன்ற வெளிப்புற விவரக்குறிப்பு தொகுப்புகளைப் பயன்படுத்தலாம்.
தற்காலிக சேமிப்பு முடிவுகள்
எங்கள் குறியீடு விலையுயர்ந்த கணக்கீடுகளைச் செய்ய வேண்டுமானால், நேரத்தைச் சேமிக்க விளைவுகளைத் தேக்ககப்படுத்துவதை நாங்கள் பரிசீலிக்கலாம்.
குறியீடு மறுசீரமைப்பு
எளிதாகப் படிக்கவும் பராமரிக்கவும் குறியீட்டை மறுசீரமைப்பது சில நேரங்களில் அதை மேம்படுத்துவதற்கு அவசியமான பகுதியாகும். ஒரு வேகமான நிரல் சுத்தமாகவும் இருக்கலாம்.
ஜஸ்ட்-இன்-டைம் கம்பைலேஷன் (JIT) பயன்படுத்தவும்
PyPy அல்லது Numba போன்ற நூலகங்கள் JIT தொகுப்பை வழங்க முடியும், இது சில வகையான பைதான் குறியீட்டை கணிசமாக வேகப்படுத்துகிறது.
பைத்தானை மேம்படுத்தவும்
பைத்தானின் சமீபத்திய பதிப்பைப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள், ஏனெனில் புதிய பதிப்புகளில் செயல்திறன் மேம்பாடுகள் உள்ளன.
இணைநிலை மற்றும் ஒத்திசைவு
இணையாக செய்யக்கூடிய செயல்முறைகளுக்கு, மல்டிபிராசசிங், த்ரெடிங் அல்லது அசின்சியோ போன்ற இணையான மற்றும் ஒத்திசைவு நுட்பங்களை ஆராயவும்.
தரப்படுத்தல் மற்றும் விவரக்குறிப்பு தேர்வுமுறையின் முக்கிய இயக்கிகளாக இருக்க வேண்டும் என்பதை நினைவில் கொள்ளுங்கள். செயல்திறனில் மிகவும் குறிப்பிடத்தக்க விளைவுகளை ஏற்படுத்தும் எங்கள் குறியீட்டின் பகுதிகளை மேம்படுத்துவதில் கவனம் செலுத்துங்கள், மேலும் குறைபாடுகளை அறிமுகப்படுத்தாமல் விரும்பிய விளைவுகளைக் கொண்டிருப்பதை உறுதிசெய்ய உங்கள் மேம்பாடுகளைத் தொடர்ந்து சோதிக்கவும்.
முடிவுரை
முடிவில், மேம்படுத்தப்பட்ட செயல்திறன் மற்றும் வள செயல்திறன் ஆகியவற்றிற்கு பைதான் குறியீடு தேர்வுமுறை முக்கியமானது. டெவலப்பர்கள், பொருத்தமான தரவு கட்டமைப்புகளைத் தேர்ந்தெடுப்பது, உள்ளமைக்கப்பட்ட செயல்பாடுகளை மேம்படுத்துதல், கூடுதல் சுழல்களைக் குறைத்தல் மற்றும் நினைவகத்தை திறம்பட நிர்வகிப்பது போன்ற பல்வேறு நுட்பங்களைப் பயன்படுத்தி தங்கள் பைதான் பயன்பாடுகளின் செயல்பாட்டின் வேகம் மற்றும் பதிலளிக்கும் தன்மையை பெரிதும் அதிகரிக்க முடியும். தொடர்ச்சியான தரப்படுத்தல் மற்றும் விவரக்குறிப்பு தேர்வுமுறை முயற்சிகளை இயக்க வேண்டும், குறியீடு முன்னேற்றங்கள் நிஜ-உலக செயல்திறன் தேவைகளுடன் பொருந்துவதை உறுதி செய்கிறது. ஒரு நீண்ட கால திட்ட வெற்றிக்கு உத்தரவாதம் அளிக்கவும், புதிய சிக்கல்களை அறிமுகப்படுத்துவதற்கான வாய்ப்பைக் குறைக்கவும், குறியீட்டை மேம்படுத்துதல் குறியீடு வாசிப்புத்திறன் மற்றும் பராமரிப்பின் நோக்கங்களுடன் தொடர்ந்து சமநிலைப்படுத்தப்பட வேண்டும்.