Python සම්මත පුස්තකාලයේ timeit මොඩියුලය භාවිතයෙන්, ඔබට ඔබගේ කේතයේ ක්‍රියාවලියක් ක්‍රියාත්මක කිරීමේ කාලය පහසුවෙන් මැනිය හැක. මෙය ඉක්මන් පරීක්ෂාවක් සඳහා ප්‍රයෝජනවත් වේ.
පහත අවස්ථා දෙක මෙහිදී සාකච්ඡා කෙරේ.
- පයිතන් ගොනුවක මැනීම:
timeit.timeit(),timeit.repeat() - Jupyter සටහන් පොත සමඟ මැනීම:
%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]
Jupyter සටහන් පොත සමඟ මැනීම:%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 ලිවීමයි, එබැවින් එය භාවිතා කිරීමට පහසුම වේ.
