పైథాన్ స్టాండర్డ్ లైబ్రరీ యొక్క టైమ్‌ఇట్ మాడ్యూల్‌ని ఉపయోగించి, మీరు మీ కోడ్‌లో ప్రక్రియ యొక్క అమలు సమయాన్ని సులభంగా కొలవవచ్చు. త్వరిత తనిఖీకి ఇది ఉపయోగపడుతుంది.
కింది రెండు సందర్భాలు ఇక్కడ చర్చించబడతాయి.
- పైథాన్ ఫైల్‌లో కొలత:
timeit.timeit(),timeit.repeat() - జూపిటర్ నోట్‌బుక్‌తో కొలత:
%timeit,%%timeit
ప్రోగ్రామ్‌లో గడిచిన సమయాన్ని కొలవడానికి time.time()ని ఉపయోగించడం మరొక మార్గం.
పైథాన్ ఫైళ్లలో కొలతలు: timeit.timeit(), timeit.repeat()
ఉదాహరణగా, మేము ఒక సాధారణ ఫంక్షన్, test(n) యొక్క ప్రాసెసింగ్ సమయాన్ని కొలుస్తాము, ఇది n వరుస సంఖ్యల మొత్తాన్ని గణిస్తుంది.
import timeit
def test(n):
return sum(range(n))
n = 10000
loop = 1000
result = timeit.timeit('test(n)', globals=globals(), number=loop)
print(result / loop)
# 0.0002666301020071842
మీరు timeit.timeit() ఫంక్షన్‌కు స్ట్రింగ్‌గా కొలవాలనుకుంటున్న కోడ్‌ను పాస్ చేస్తే, అది NUMBER సార్లు అమలు చేయబడుతుంది మరియు దానికి తీసుకున్న సమయం తిరిగి ఇవ్వబడుతుంది.
సంఖ్యకు డిఫాల్ట్ విలువ 1,000,000. మీరు సమయం తీసుకునే ప్రక్రియ కోసం డిఫాల్ట్ విలువను ఉపయోగిస్తే, దానికి చాలా సమయం పడుతుందని గమనించండి.
గ్లోబల్స్()ని ఆర్గ్యుమెంట్ గ్లోబల్స్‌గా పాస్ చేయడం ద్వారా, కోడ్ గ్లోబల్ నేమ్‌స్పేస్‌లో అమలు చేయబడుతుంది.
ఇది లేకుండా, పై ఉదాహరణలో ఫంక్షన్ టెస్ట్ మరియు వేరియబుల్ n గుర్తించబడవు.
పేర్కొనవలసిన కోడ్ స్ట్రింగ్‌కు బదులుగా కాల్ చేయగల ఆబ్జెక్ట్ కావచ్చు, కాబట్టి దీనిని ఆర్గ్యుమెంట్‌లు లేకుండా లాంబ్డా వ్యక్తీకరణగా పేర్కొనవచ్చు; ఈ సందర్భంలో, గ్లోబల్స్ వాదనను పేర్కొనవలసిన అవసరం లేదు.
result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287
ఫలితం యొక్క యూనిట్ సెకన్లు. ఇక్కడ, అవుట్‌పుట్ అనేది ఎగ్జిక్యూషన్‌ల సంఖ్యతో విభజించబడిన ఎగ్జిక్యూషన్‌కు ప్రాసెసింగ్ సమయం.
మీరు విభజించకపోతే, మీరు అమలు చేసే సంఖ్యను పెంచే కొద్దీ ఫలితం విలువ పెద్దదిగా మారుతుంది.
print(timeit.timeit(lambda: test(n), number=1))
print(timeit.timeit(lambda: test(n), number=10))
print(timeit.timeit(lambda: test(n), number=100))
# 0.0003999490290880203
# 0.0038685189792886376
# 0.03517670702422038
timeit.repeat() ఫంక్షన్‌ని ఉపయోగించి, timeit()ని పదే పదే అమలు చేయవచ్చు. ఫలితం జాబితాగా పొందబడుతుంది.
repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]
జూపిటర్ నోట్‌బుక్‌తో కొలత:%timeit, %%timeit
Jupyter Notebook (IPython)లో, మీరు క్రింది మేజిక్ ఆదేశాలను ఉపయోగించవచ్చు; టైమ్‌ఇట్ మాడ్యూల్‌ను దిగుమతి చేయవలసిన అవసరం లేదు.
%timeit%%timeit
%సమయం
%timeitలో, కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల వంటి ఖాళీతో వేరు చేయబడిన లక్ష్య కోడ్‌ను పేర్కొనండి.
డిఫాల్ట్‌గా, timeit.timeit()లో సంఖ్య మరియు పునరావృతం స్వయంచాలకంగా నిర్ణయించబడతాయి. మీరు వాటిని -n మరియు -r ఎంపికలతో కూడా పేర్కొనవచ్చు.
ఫలితాలు సగటు మరియు ప్రామాణిక విచలనం వలె లెక్కించబడతాయి.
%timeit test(n)
# 259 µs ± 4.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit -r 3 -n 10000 test(n)
# 237 µs ± 6.44 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)
%% సమయం
మేజిక్ కమాండ్ %%timeit మొత్తం సెల్ యొక్క ప్రాసెసింగ్ సమయాన్ని కొలవడానికి ఉపయోగించవచ్చు.
ఉదాహరణగా, NumPyని ఉపయోగించి అదే విధానాన్ని అమలు చేద్దాం. -n మరియు -r ఎంపికలను విస్మరించవచ్చు.
మేము మొత్తం సెల్ యొక్క ప్రాసెసింగ్ సమయాన్ని కొలుస్తాము కాబట్టి, క్రింది ఉదాహరణలో NumPyని దిగుమతి చేసుకునే సమయం ఉంటుంది.
%%timeit -r 3 -n 10000
import numpy as np
a = np.arange(n)
np.sum(a)
# 19.7 µs ± 9.57 µs per loop (mean ± std. dev. of 3 runs, 10000 loops each)
లక్ష్యం కోడ్‌ని %%timeit కోసం ఆర్గ్యుమెంట్‌గా పేర్కొనాల్సిన అవసరం లేదు. మీరు చేయాల్సిందల్లా సెల్ ప్రారంభంలో %%timeit అని వ్రాయండి, కనుక ఇది ఉపయోగించడానికి సులభమైనది.
