En utilisant le module timeit de la bibliothèque standard Python, vous pouvez facilement mesurer le temps d'exécution d'un processus dans votre code. Ceci est utile pour une vérification rapide.
Les deux cas suivants seront examinés ici.
- Mesure dans un fichier Python :
timeit.timeit(),timeit.repeat() - Mesure avec Jupyter Notebook :
%timeit,%%timeit
Une autre façon est d'utiliser time.time() pour mesurer le temps écoulé dans le programme.
Mesures dans les fichiers Python : timeit.timeit(), timeit.repeat()
A titre d'exemple, nous allons mesurer le temps de traitement d'une fonction simple, test(n), qui calcule la somme de n nombres consécutifs.
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 vous passez le code que vous voulez mesurer sous forme de chaîne à la fonction timeit.timeit(), il sera exécuté NUMÉRO de fois et le temps qu'il a pris sera renvoyé.
La valeur par défaut du nombre est 1 000 000. Notez que si vous utilisez la valeur par défaut pour un processus qui prend du temps, celui-ci prendra beaucoup de temps.
En passant globals() comme argument globals, le code sera exécuté dans l'espace de nom global.
Sans cela, la fonction test et la variable n ne sont pas reconnues dans l'exemple ci-dessus.
Le code à spécifier peut être un objet appelable au lieu d'une chaîne de caractères, il peut donc être spécifié comme une expression lambda sans arguments ; dans ce cas, l'argument globals n'a pas besoin d'être spécifié.
result = timeit.timeit(lambda: test(n), number=loop)
print(result / loop)
# 0.00027574066299712287
L'unité du résultat est la seconde. Ici, le résultat est le temps de traitement par exécution divisé par le nombre d'exécutions.
Si vous ne divisez pas, la valeur du résultat deviendra simplement plus grande à mesure que vous augmenterez le nombre d'exécutions.
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
En utilisant la fonction timeit.repeat(), timeit() peut être exécuté de manière répétée. Le résultat sera obtenu sous forme de liste.
repeat = 5
print(timeit.repeat(lambda: test(n), repeat=repeat, number=100))
# [0.044914519996382296, 0.039663890027441084, 0.02868645201670006, 0.022745631984435022, 0.023260265996214002]
Mesure avec Jupyter Notebook :%timeit, %%timeit
Dans Jupyter Notebook (IPython), vous pouvez utiliser les commandes magiques suivantes ; il n'est pas nécessaire d'importer le module timeit.
%timeit%%timeit
%timeit
Dans %timeit, spécifiez le code cible séparé par un espace comme les arguments de ligne de commande.
Par défaut, le nombre et la répétition dans timeit.timeit() sont déterminés automatiquement. Vous pouvez également les spécifier avec les options -n et -r.
Les résultats sont calculés en tant que moyenne et écart-type.
%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
La commande magique %%timeit peut être utilisée pour mesurer le temps de traitement d'une cellule entière.
À titre d'exemple, exécutons le même processus en utilisant NumPy. Les options -n et -r peuvent être omises.
Comme nous mesurons le temps de traitement de l'ensemble de la cellule, l'exemple suivant inclut le temps d'importation de 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)
Il n'est pas nécessaire de spécifier le code cible comme argument pour %%timeit. Tout ce que vous avez à faire est d'écrire %%timeit au début d'une cellule, c'est donc la plus facile à utiliser.