Mitjançant el mòdul timeit de la biblioteca estàndard de Python, podeu mesurar fàcilment el temps d’execució d’un procés al vostre codi. Això és útil per a una comprovació ràpida.
Els dos casos següents es tractaran aquí.
- Mesura en un fitxer Python:
timeit.timeit(),timeit.repeat() - Mesurament amb Jupyter Notebook:
%timeit,%%timeit
Una altra manera és utilitzar time.time() per mesurar el temps transcorregut al programa.
Mesures en fitxers Python: timeit.timeit(), timeit.repeat()
Com a exemple, mesurarem el temps de processament d’una funció simple, test(n), que calcula la suma de n nombres consecutius.
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
Si passeu el codi que voleu mesurar com a cadena a la funció timeit.timeit(), s’executarà NOMBRE DE vegades i es retornarà el temps que va trigar.
El valor predeterminat per al número és 1.000.000. Tingueu en compte que si utilitzeu el valor predeterminat per a un procés que requereix molt de temps, trigarà molt de temps.
En passar globals() com a argument globals, el codi s’executarà a l’espai de noms global.
Sense això, la prova de funció i la variable n no es reconeixen a l’exemple anterior.
El codi que s’ha d’especificar pot ser un objecte cridable en lloc d’una cadena, de manera que es pot especificar com una expressió lambda sense arguments; en aquest cas, no cal especificar l’argument globals.
result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287
La unitat del resultat són els segons. Aquí, la sortida és el temps de processament per execució dividit pel nombre d’execucions.
Si no dividiu, el valor del resultat simplement augmentarà a mesura que augmenteu el nombre d’execucions.
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
Mitjançant la funció timeit.repeat(), timeit() es pot executar repetidament. El resultat s’obtindrà com una llista.
repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]
Mesurament amb Jupyter Notebook:%timeit, %%timeit
A Jupyter Notebook (IPython), podeu utilitzar les ordres màgiques següents; no cal importar el mòdul timeit.
%timeit%%timeit
%timeit
A %timeit, especifiqueu el codi de destinació separat per un espai com els arguments de la línia d’ordres.
Per defecte, el nombre i la repetició a timeit.timeit() es determinen automàticament. També podeu especificar-los amb les opcions -n i -r.
Els resultats es calculen com a mitjana i desviació estàndard.
%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
L’ordre màgic %%time es pot utilitzar per mesurar el temps de processament d’una cel·la sencera.
Com a exemple, executem el mateix procés amb NumPy. Les opcions -n i -r es poden ometre.
Com que mesurem el temps de processament de tota la cel·la, l’exemple següent inclou el temps per importar 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)
No cal especificar el codi objectiu com a argument per a %%timeit. Tot el que heu de fer és escriure %%timeit al principi d’una cel·la, de manera que és el més fàcil d’utilitzar.