అనేక చర్యలు లేదా డేటాను ప్రాసెస్ చేయడానికి కాల్ చేసే పనిని చేస్తున్నప్పుడు ఇది అవసరం. అందువల్ల, కొన్ని అసమర్థ కోడ్ బ్లాక్‌లు మరియు ఫంక్షనాలిటీలను స్విచ్ అవుట్ చేయడం మరియు మెరుగుపరచడం ద్వారా కింది వంటి అద్భుతమైన ఫలితాలు పొందవచ్చు:
- అప్లికేషన్ పనితీరును పెంచండి
- చదవగలిగే మరియు వ్యవస్థీకృత కోడ్‌ని సృష్టించండి
- దోష పర్యవేక్షణ మరియు డీబగ్గింగ్‌ను సులభతరం చేయండి
- గణనీయమైన గణన శక్తిని ఆదా చేయండి మరియు మొదలైనవి
మీ కోడ్‌ని ప్రొఫైల్ చేయండి
మేము ఆప్టిమైజ్ చేయడం ప్రారంభించే ముందు, ప్రాజెక్ట్ కోడ్‌ని నెమ్మదించే భాగాలను గుర్తించడం చాలా అవసరం. పైథాన్‌లో ప్రొఫైలింగ్ కోసం సాంకేతికతలు cProfile మరియు ప్రొఫైల్ ప్యాకేజీలను కలిగి ఉంటాయి. నిర్దిష్ట విధులు మరియు కోడ్ లైన్లు ఎంత త్వరగా ఎగ్జిక్యూట్ అవుతాయో అంచనా వేయడానికి అటువంటి సాధనాలను ఉపయోగించండి. cProfile మాడ్యూల్ ప్రతి స్క్రిప్ట్ ఫంక్షన్‌ని అమలు చేయడానికి ఎంత సమయం తీసుకుంటుందో వివరించే నివేదికను ఉత్పత్తి చేస్తుంది. నెమ్మదిగా నడుస్తున్న ఏవైనా ఫంక్షన్‌లను కనుగొనడంలో ఈ నివేదిక మాకు సహాయపడుతుంది, తద్వారా మేము వాటిని మెరుగుపరచగలము.
కోడ్ స్నిప్పెట్:
దిగుమతి cProfile వంటి cP
డెఫ్ లెక్కింపు ( ఇన్పుట్ సంఖ్య ) :
మొత్తం_ఇన్పుట్_సంఖ్యలు = 0
అయితే ఇన్పుట్ సంఖ్య > 0 :
మొత్తం_ఇన్పుట్_సంఖ్యలు + = ఇన్పుట్ సంఖ్య % 10
ఇన్పుట్ నంబర్ // = 10
ముద్రణ ( 'ఇన్పుట్ నంబర్‌లోని అన్ని అంకెల మొత్తం: 'sum_of_input_numbers'' )
తిరిగి మొత్తం_ఇన్పుట్_సంఖ్యలు
డెఫ్ ప్రధాన_ఫంక్ ( ) :
cP. పరుగు ( 'కాలిక్యులేట్ సమ్(9876543789)' )
ఉంటే __పేరు__ == '__ప్రధాన__' :
ప్రధాన_ఫంక్ ( )
అవుట్‌పుట్ యొక్క మొదటి లైన్‌లో చూసినట్లుగా ప్రోగ్రామ్ మొత్తం ఐదు ఫంక్షన్ కాల్‌లను చేస్తుంది. ప్రతి ఫంక్షన్ కాల్ యొక్క వివరాలు క్రింది కొన్ని పంక్తులలో చూపబడతాయి, ఇందులో ఫంక్షన్ ఎన్నిసార్లు ప్రారంభించబడింది, ఫంక్షన్‌లో మొత్తం సమయం వ్యవధి, ఒక్కో కాల్‌కు సమయం మరియు ఫంక్షన్‌లోని మొత్తం సమయం (సహా అన్ని విధులు అంటారు).
అదనంగా, ప్రోగ్రామ్ ప్రాంప్ట్ స్క్రీన్‌పై ఒక నివేదికను ప్రింట్ చేస్తుంది, ఇది ప్రోగ్రామ్ తన అన్ని పనుల అమలు సమయాన్ని 0.000 సెకన్లలోపు పూర్తి చేస్తుందని చూపిస్తుంది. ఇది ప్రోగ్రామ్ ఎంత వేగంగా ఉందో చూపిస్తుంది.
సరైన డేటా నిర్మాణాన్ని ఎంచుకోండి
పనితీరు లక్షణాలు డేటా నిర్మాణంపై ఆధారపడి ఉంటాయి. ప్రత్యేకించి, సాధారణ-ప్రయోజన నిల్వకు సంబంధించిన జాబితాల కంటే డిక్షనరీలు వెతకడం కోసం వేగంగా ఉంటాయి. మీకు తెలిసినట్లయితే మేము మీ డేటాపై నిర్వహించే కార్యకలాపాలకు అత్యంత అనుకూలమైన డేటా నిర్మాణాన్ని ఎంచుకోండి. కింది ఉదాహరణ డేటా నిర్మాణంలో ఒక మూలకం ఉందో లేదో నిర్ధారించడానికి ఒకే విధమైన ప్రక్రియ కోసం వివిధ డేటా స్ట్రక్చర్‌ల ప్రభావాన్ని పరిశీలిస్తుంది.
మేము ప్రతి డేటా నిర్మాణంలో ఒక మూలకం ఉందో లేదో తనిఖీ చేయడానికి పట్టే సమయాన్ని అంచనా వేస్తాము-జాబితా, సమితి మరియు నిఘంటువు- మరియు వాటిని సరిపోల్చండి.
OptimizeDataType.py:
దిగుమతి టైమి వంటి ttదిగుమతి యాదృచ్ఛికంగా వంటి rndobj
# పూర్ణాంకాల జాబితాను రూపొందించండి
యాదృచ్ఛిక_డేటా_జాబితా = [ rndobj. రాండింట్ ( 1 , 10000 ) కోసం _ లో పరిధి ( 10000 ) ]
# అదే డేటా నుండి సెట్‌ను సృష్టించండి
random_data_set = సెట్ ( యాదృచ్ఛిక_డేటా_జాబితా )
# కీల వలె అదే డేటాతో నిఘంటువును సృష్టించండి
obj_DataDictionary = { ఒకదానిపై: ఏదీ లేదు కోసం ఒకదానిపై లో యాదృచ్ఛిక_డేటా_జాబితా }
# శోధించడానికి మూలకం (డేటాలో ఉంది)
random_number_to_find = rndobj. ఎంపిక ( యాదృచ్ఛిక_డేటా_జాబితా )
# జాబితాలో సభ్యత్వాన్ని తనిఖీ చేయడానికి సమయాన్ని కొలవండి
జాబితా_సమయం = tt. టైమి ( లాంబ్డా : కనుగొనడానికి_యాదృచ్ఛిక_సంఖ్య లో యాదృచ్ఛిక_డేటా_జాబితా , సంఖ్య = 1000 )
# సమితిలో సభ్యత్వాన్ని తనిఖీ చేయడానికి సమయాన్ని కొలవండి
సమయం సరిచేయి = tt. టైమి ( లాంబ్డా : కనుగొనడానికి_యాదృచ్ఛిక_సంఖ్య లో random_data_set , సంఖ్య = 1000 )
# నిఘంటువులో సభ్యత్వాన్ని తనిఖీ చేయడానికి సమయాన్ని కొలవండి
డిక్ట్_టైమ్ = tt. టైమి ( లాంబ్డా : కనుగొనడానికి_యాదృచ్ఛిక_సంఖ్య లో obj_DataDictionary , సంఖ్య = 1000 )
ముద్రణ ( f 'జాబితా సభ్యత్వం తనిఖీ సమయం: {list_time:.6f} సెకన్లు' )
ముద్రణ ( f 'సభ్యత్వ తనిఖీ సమయాన్ని సెట్ చేయండి: {set_time:.6f} సెకన్లు' )
ముద్రణ ( f 'నిఘంటువు సభ్యత్వం తనిఖీ సమయం: {dict_time:.6f} సెకన్లు' )
సభ్యత్వ తనిఖీలు చేస్తున్నప్పుడు ఈ కోడ్ జాబితాలు, సెట్‌లు మరియు నిఘంటువుల పనితీరును సరిపోల్చుతుంది. సాధారణంగా, సెట్‌లు మరియు డిక్షనరీలు మెంబర్‌షిప్ పరీక్షల జాబితాల కంటే గణనీయంగా వేగంగా ఉంటాయి, ఎందుకంటే అవి హాష్-ఆధారిత శోధనలను ఉపయోగిస్తాయి, కాబట్టి అవి O(1) యొక్క సగటు సమయ సంక్లిష్టతను కలిగి ఉంటాయి. జాబితాలు, మరోవైపు, O(n) సమయ సంక్లిష్టతతో సభ్యత్వ పరీక్షలకు దారితీసే సరళ శోధనలను తప్పనిసరిగా చేయాలి.
లూప్‌లకు బదులుగా అంతర్నిర్మిత ఫంక్షన్‌లను ఉపయోగించండి
ఫిల్టరింగ్, సార్టింగ్ మరియు మ్యాపింగ్ వంటి సాధారణ పనులను నిర్వహించడానికి పైథాన్‌లోని అనేక అంతర్నిర్మిత విధులు లేదా పద్ధతులు ఉపయోగించవచ్చు. ఒకరి లూప్‌లను సృష్టించడం కంటే ఈ రొటీన్‌లను ఉపయోగించడం కోడ్‌ను వేగవంతం చేయడంలో సహాయపడుతుంది ఎందుకంటే అవి తరచుగా పనితీరు-ఆప్టిమైజ్ చేయబడతాయి.
సాధారణ ఉద్యోగాల (మ్యాప్(), ఫిల్టర్(), మరియు క్రమబద్ధీకరించబడిన() వంటివి) కోసం అంతర్నిర్మిత ఫంక్షన్‌లను ఉపయోగించడం ద్వారా కస్టమ్ లూప్‌లను సృష్టించే పనితీరును సరిపోల్చడానికి కొన్ని నమూనా కోడ్‌ని రూపొందిద్దాం. వివిధ మ్యాపింగ్, ఫిల్ట్రేషన్ మరియు సార్టింగ్ పద్ధతులు ఎంత బాగా పనిచేస్తాయో మేము మూల్యాంకనం చేస్తాము.
BuiltInFunctions.py:
దిగుమతి టైమి వంటి tt# సంఖ్యల_జాబితా యొక్క నమూనా జాబితా
సంఖ్యలు_జాబితా = జాబితా ( పరిధి ( 1 , 10000 ) )
# లూప్‌ని ఉపయోగించి వర్గ సంఖ్యల_జాబితాకు ఫంక్షన్
డెఫ్ చతురస్రం_ఉపయోగించి_లూప్ ( సంఖ్యలు_జాబితా ) :
చదరపు_ఫలితం = [ ]
కోసం ఒకదానిపై లో సంఖ్యలు_జాబితా:
చదరపు_ఫలితం. జోడించు ( ఒకదానిపై ** 2 )
తిరిగి చదరపు_ఫలితం
# లూప్‌ని ఉపయోగించి సరి సంఖ్యల_జాబితాని ఫిల్టర్ చేయడానికి ఫంక్షన్
డెఫ్ ఫిల్టర్_even_using_loop ( సంఖ్యలు_జాబితా ) :
ఫిల్టర్_ఫలితం = [ ]
కోసం ఒకదానిపై లో సంఖ్యలు_జాబితా:
ఉంటే ఒక% మీద 2 == 0 :
ఫిల్టర్_ఫలితం. జోడించు ( ఒకదానిపై )
తిరిగి ఫిల్టర్_ఫలితం
# లూప్‌ని ఉపయోగించి సంఖ్యల_జాబితాను క్రమబద్ధీకరించడానికి ఫంక్షన్
డెఫ్ లూప్_ఉపయోగించి_క్రమబద్ధీకరించండి ( సంఖ్యలు_జాబితా ) :
తిరిగి క్రమబద్ధీకరించబడింది ( సంఖ్యలు_జాబితా )
# మ్యాప్()ని ఉపయోగించి వర్గ సంఖ్యల_జాబితాకు సమయాన్ని కొలవండి
మ్యాప్_టైమ్ = tt. టైమి ( లాంబ్డా : జాబితా ( పటం ( లాంబ్డా x: x ** 2 , సంఖ్యలు_జాబితా ) ) , సంఖ్య = 1000 )
# ఫిల్టర్()ని ఉపయోగించి సరి సంఖ్యల_జాబితాని ఫిల్టర్ చేయడానికి సమయాన్ని కొలవండి
ఫిల్టర్_సమయం = tt. టైమి ( లాంబ్డా : జాబితా ( వడపోత ( లాంబ్డా x: x % 2 == 0 , సంఖ్యలు_జాబితా ) ) , సంఖ్య = 1000 )
# క్రమబద్ధీకరించబడిన()ని ఉపయోగించి సంఖ్యల_జాబితాను క్రమబద్ధీకరించడానికి సమయాన్ని కొలవండి
క్రమబద్ధీకరించబడిన_సమయం = tt. టైమి ( లాంబ్డా : క్రమబద్ధీకరించబడింది ( సంఖ్యలు_జాబితా ) , సంఖ్య = 1000 )
# లూప్‌ని ఉపయోగించి వర్గ సంఖ్యల_జాబితాకు సమయాన్ని కొలవండి
లూప్_మ్యాప్_టైమ్ = tt. టైమి ( లాంబ్డా : చతురస్రం_ఉపయోగించి_లూప్ ( సంఖ్యలు_జాబితా ) , సంఖ్య = 1000 )
# లూప్‌ని ఉపయోగించి సరి సంఖ్యల_జాబితాని ఫిల్టర్ చేయడానికి సమయాన్ని కొలవండి
లూప్_ఫిల్టర్_టైమ్ = 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 ) )
# రివర్స్ ఆర్డర్‌లో జాబితాపై మళ్ళించే ఫంక్షన్
డెఫ్ loop_reverse_iteration ( ) :
ఫలితం_రివర్స్ = [ ]
కోసం j లో పరిధి ( మాత్రమే ( సంఖ్యలు_జాబితా ) - 1 , - 1 , - 1 ) :
ఫలితం_రివర్స్. జోడించు ( సంఖ్యలు_జాబితా [ j ] )
తిరిగి ఫలితం_రివర్స్
# పరిధి()ని ఉపయోగించి జాబితాపై పునరావృతం చేయడానికి ఫంక్షన్
డెఫ్ loop_range_iteration ( ) :
ఫలితం_పరిధి = [ ]
కోసం కె లో పరిధి ( మాత్రమే ( సంఖ్యలు_జాబితా ) ) :
ఫలితం_పరిధి. జోడించు ( సంఖ్యలు_జాబితా [ కె ] )
తిరిగి ఫలితం_పరిధి
# రివర్స్ పునరావృతం చేయడానికి పట్టే సమయాన్ని కొలవండి
రివర్స్_టైమ్ = tt. టైమి ( loop_reverse_iteration , సంఖ్య = 1000 )
# పరిధి పునరావృతం చేయడానికి పట్టే సమయాన్ని కొలవండి
పరిధి_సమయం = tt. టైమి ( loop_range_iteration , సంఖ్య = 1000 )
ముద్రణ ( 'సంఖ్య జాబితాలో 100000 రికార్డులు ఉన్నాయి' )
ముద్రణ ( f 'రివర్స్ పునరావృత సమయం: {reverse_time:.6f} సెకన్లు' )
ముద్రణ ( f 'పరిధి పునరావృత సమయం: {range_time:.6f} సెకన్లు' )
అనవసరమైన ఫంక్షన్ కాల్‌లను నివారించండి
ఫంక్షన్‌ని పిలిచిన ప్రతిసారీ కొంత ఓవర్‌హెడ్ ఉంటుంది. అనవసరమైన ఫంక్షన్ కాల్‌లను నివారించినట్లయితే కోడ్ మరింత వేగంగా నడుస్తుంది. ఉదాహరణకు, విలువను లెక్కించే ఫంక్షన్‌ను పదే పదే అమలు చేయడానికి బదులుగా, గణన ఫలితాన్ని వేరియబుల్‌లో నిల్వ చేసి, దాన్ని ఉపయోగించడాన్ని ప్రయత్నించండి.
ప్రొఫైలింగ్ కోసం సాధనాలు
మీ కోడ్ పనితీరు గురించి మరింత తెలుసుకోవడానికి, అంతర్నిర్మిత ప్రొఫైలింగ్‌తో పాటు, మేము cProfile, Pyflame లేదా SnakeViz వంటి బాహ్య ప్రొఫైలింగ్ ప్యాకేజీలను ఉపయోగించవచ్చు.
కాష్ ఫలితాలు
మా కోడ్ ఖరీదైన గణనలను నిర్వహించాల్సిన అవసరం ఉన్నట్లయితే, సమయాన్ని ఆదా చేయడానికి ఫలితాలను కాష్ చేయడాన్ని మేము పరిగణించవచ్చు.
కోడ్ రీఫ్యాక్టరింగ్
చదవడం మరియు నిర్వహించడం సులభతరం చేయడానికి కోడ్‌ను రీఫ్యాక్టరింగ్ చేయడం కొన్నిసార్లు దానిని ఆప్టిమైజ్ చేయడంలో అవసరమైన భాగం. వేగవంతమైన ప్రోగ్రామ్ కూడా శుభ్రంగా ఉండవచ్చు.
జస్ట్-ఇన్-టైమ్ కంపైలేషన్ (JIT) ఉపయోగించండి
PyPy లేదా Numba వంటి లైబ్రరీలు కొన్ని రకాల పైథాన్ కోడ్‌లను గణనీయంగా వేగవంతం చేసే JIT సంకలనాన్ని అందించగలవు.
పైథాన్‌ని అప్‌గ్రేడ్ చేయండి
కొత్త వెర్షన్లలో తరచుగా పనితీరు మెరుగుదలలు ఉంటాయి కాబట్టి మీరు పైథాన్ యొక్క తాజా వెర్షన్‌ని ఉపయోగిస్తున్నారని నిర్ధారించుకోండి.
సమాంతరత మరియు ఏకీకరణ
సమాంతరంగా ఉండే ప్రక్రియల కోసం, మల్టీప్రాసెసింగ్, థ్రెడింగ్ లేదా అసిన్సియో వంటి సమాంతర మరియు సమకాలీకరణ పద్ధతులను పరిశోధించండి.
బెంచ్‌మార్కింగ్ మరియు ప్రొఫైలింగ్ ఆప్టిమైజేషన్ యొక్క ప్రధాన డ్రైవర్లుగా ఉండాలని గుర్తుంచుకోండి. పనితీరుపై అత్యంత ముఖ్యమైన ప్రభావాలను కలిగి ఉన్న మా కోడ్ యొక్క ప్రాంతాలను మెరుగుపరచడంపై దృష్టి పెట్టండి మరియు మరిన్ని లోపాలను పరిచయం చేయకుండా కావలసిన ప్రభావాలను కలిగి ఉన్నాయని నిర్ధారించుకోవడానికి మీ మెరుగుదలలను నిరంతరం పరీక్షించండి.
ముగింపు
ముగింపులో, మెరుగైన పనితీరు మరియు వనరుల ప్రభావానికి పైథాన్ కోడ్ ఆప్టిమైజేషన్ కీలకం. డెవలపర్‌లు తగిన డేటా స్ట్రక్చర్‌లను ఎంచుకోవడం, అంతర్నిర్మిత ఫంక్షన్‌లను పెంచడం, అదనపు లూప్‌లను తగ్గించడం మరియు మెమరీని సమర్థవంతంగా నిర్వహించడం వంటి వివిధ పద్ధతులను ఉపయోగించి వారి పైథాన్ అప్లికేషన్‌ల అమలు వేగం మరియు ప్రతిస్పందనను బాగా పెంచవచ్చు. నిరంతర బెంచ్‌మార్కింగ్ మరియు ప్రొఫైలింగ్ ఆప్టిమైజేషన్ ప్రయత్నాలను నిర్దేశించాలి, కోడ్ పురోగతి వాస్తవ-ప్రపంచ పనితీరు అవసరాలకు సరిపోయేలా చూసుకోవాలి. దీర్ఘకాలిక ప్రాజెక్ట్ విజయానికి హామీ ఇవ్వడానికి మరియు కొత్త సమస్యలను పరిచయం చేసే అవకాశాన్ని తగ్గించడానికి, కోడ్‌ని ఆప్టిమైజ్ చేయడం అనేది కోడ్ రీడబిలిటీ మరియు మెయింటెనబిలిటీ యొక్క లక్ష్యాలతో నిరంతరం సమతుల్యం చేయబడాలి.