Gamit ang timeit module ng Python standard library, madali mong masusukat ang oras ng pagpapatupad ng isang proseso sa iyong code. Ito ay kapaki-pakinabang para sa isang mabilis na pagsusuri.
Ang sumusunod na dalawang kaso ay tatalakayin dito.
- Sukatin sa isang Python file:
timeit.timeit(),timeit.repeat() - Pagsukat gamit ang Jupyter Notebook:
%timeit,%%timeit
Ang isa pang paraan ay ang paggamit ng time.time() upang sukatin ang lumipas na oras sa programa.
Mga sukat sa mga file ng Python: timeit.timeit(), timeit.repeat()
Bilang halimbawa, susukatin natin ang oras ng pagproseso ng isang simpleng function, test(n), na kinakalkula ang kabuuan ng n magkakasunod na numero.
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
Kung ipapasa mo ang code na gusto mong sukatin bilang isang string sa timeit.timeit() function, ito ay isasagawa nang NUMBER beses at ang oras na kinuha nito ay ibabalik.
Ang default na halaga para sa numero ay 1,000,000. Tandaan na kung gagamitin mo ang default na halaga para sa isang prosesong tumatagal, aabutin ito ng maraming oras.
Sa pamamagitan ng pagpasa sa globals() bilang argument globals, ang code ay isasagawa sa global namespace.
Kung wala ito, hindi nakikilala ang function test at ang variable n sa halimbawa sa itaas.
Ang code na tutukuyin ay maaaring tawaging bagay sa halip na isang string, kaya maaari itong tukuyin bilang lambda expression na walang mga argumento; sa kasong ito, hindi kailangang tukuyin ang argumentong globals.
result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287
Ang yunit ng resulta ay segundo. Dito, ang output ay ang oras ng pagproseso sa bawat execution na hinati sa bilang ng mga execution.
Kung hindi mo hahatiin, ang halaga ng resulta ay magiging mas malaki habang dinadagdagan mo ang bilang ng mga execution.
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
Gamit ang timeit.repeat() function, ang timeit() ay maaaring isagawa nang paulit-ulit. Ang resulta ay makukuha bilang isang listahan.
repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]
Pagsukat gamit ang Jupyter Notebook:%timeit, %%timeit
Sa Jupyter Notebook (IPython), maaari mong gamitin ang mga sumusunod na magic command; hindi na kailangang i-import ang timeit module.
%timeit%%timeit
%timeit
Sa %timeit, tukuyin ang target na code na pinaghihiwalay ng isang puwang tulad ng mga argumento ng command line.
Bilang default, ang numero at ulitin sa timeit.timeit() ay awtomatikong tinutukoy. Maaari mo ring tukuyin ang mga ito gamit ang -n at -r na mga opsyon.
Ang mga resulta ay kinakalkula bilang mean at standard deviation.
%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
Ang magic command na %%timeit ay maaaring gamitin upang sukatin ang oras ng pagproseso ng isang buong cell.
Bilang halimbawa, patakbuhin natin ang parehong proseso gamit ang NumPy. Ang -n at -r na mga opsyon ay maaaring tanggalin.
Dahil sinusukat namin ang oras ng pagproseso ng buong cell, kasama sa sumusunod na halimbawa ang oras upang mag-import ng 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)
Hindi na kailangang tukuyin ang target na code bilang argumento para sa %%timeit. Ang kailangan mo lang gawin ay isulat ang %%timeit sa simula ng isang cell, kaya ito ang pinakamadaling gamitin.
