பைதான் நிலையான நூலகத்தின் டைம்இட் மாட்யூலைப் பயன்படுத்தி, உங்கள் குறியீட்டில் ஒரு செயல்முறையின் செயலாக்க நேரத்தை நீங்கள் எளிதாக அளவிடலாம். விரைவான சோதனைக்கு இது பயனுள்ளதாக இருக்கும்.
பின்வரும் இரண்டு வழக்குகள் இங்கே விவாதிக்கப்படும்.
- பைதான் கோப்பில் அளவிடவும்:
timeit.timeit(),timeit.repeat() - ஜூபிடர் நோட்புக் மூலம் அளவீடு:
%timeit,%%timeit
மற்றொரு வழி நிரலில் கழிந்த நேரத்தை அளவிட time.time() ஐப் பயன்படுத்துவது.
பைதான் கோப்புகளில் உள்ள அளவீடுகள்: timeit.timeit(), timeit.repeat()
உதாரணமாக, ஒரு எளிய செயல்பாட்டின் செயலாக்க நேரத்தை அளவிடுவோம், சோதனை(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.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 என்று எழுத வேண்டும், எனவே இது பயன்படுத்த எளிதானது.
