Utiliser Python Timeit pour chronométrer votre code

Dans ce tutoriel, vous apprendrez à utiliser la fonction timeit du module timeit de Python. Vous apprendrez à chronométrer des expressions et des fonctions simples en Python.

Le chronométrage de votre code peut vous aider à obtenir une estimation du temps d'exécution d'un morceau de code et à identifier les sections du code qui doivent être optimisées.

Nous commencerons par apprendre la syntaxe de la fonction timeit de Python. Ensuite, nous allons coder des exemples pour comprendre comment l'utiliser pour chronométrer des blocs de code et des fonctions dans votre module Python. Commençons.

Comment utiliser la fonction timeit de Python

Le module timeit fait partie de la bibliothèque standard de Python et vous pouvez l'importer :

import timeit

La syntaxe pour utiliser la fonction timeit du module timeit est la suivante :

timeit.timeit(stmt, setup, number)

Ici :

• stmt est le morceau de code dont le temps d'exécution doit être mesuré. Vous pouvez le spécifier sous la forme d'une simple chaîne Python ou d'une chaîne multiligne, ou encore fournir le nom de l'objet appelable.
• Comme son nom l'indique, setup désigne le morceau de code qui ne doit être exécuté qu'une seule fois, souvent comme condition préalable à l'exécution de stmt. Par exemple, supposons que vous calculez le temps d'exécution pour la création d'un tableau NumPy. Dans ce cas, l'importation de NumPy est le code d'installation et la création proprement dite est l'instruction à chronométrer.
• Le paramètre number indique le nombre de fois que la stmt est exécutée. La valeur par défaut de number est 1 million (1000000), mais vous pouvez également définir ce paramètre à n'importe quelle autre valeur de votre choix.

Maintenant que nous avons appris la syntaxe d'utilisation de la fonction timeit(), commençons à coder quelques exemples.

Chronométrage d'expressions Python simples

Dans cette section, nous allons essayer de mesurer le temps d'exécution d'expressions Python simples à l'aide de timeit.

Démarrez une REPL Python et exécutez les exemples de code suivants. Ici, nous calculons le temps d'exécution des opérations d'exponentiation et de division par le sol pour 10000 et 100000 exécutions.

Notez que nous transmettons l'instruction à chronométrer sous la forme d'une chaîne Python et que nous utilisons un point-virgule pour séparer les différentes expressions de l'instruction.

>>> import timeit
>>> timeit.timeit('3**4;3//4',number=10000)
0.0004020999999738706

>>> timeit.timeit('3**4;3//4',number=100000)
0.0013780000000451764

Exécution de Python timeit en ligne de commande

Vous pouvez également utiliser timeit en ligne de commande. Voici l'équivalent en ligne de commande de l'appel de la fonction timeit :

$ python-m timeit -n [nombre] -s [setup] [stmt]

• python -m timeit signifie que nous exécutons timeit en tant que module principal.
• n est une option de ligne de commande qui indique le nombre de fois que le code doit être exécuté. Cela équivaut à l'argument number dans l'appel de la fonction timeit().
• Vous pouvez utiliser l'option -s pour définir le code d'installation.

Ici, nous réécrivons l'exemple précédent en utilisant l'équivalent en ligne de commande :

$ python -m timeit -n 100000 '3**4;3//4'
100000 boucles, meilleur des 5 : 35,8 nsec par boucle

Dans cet exemple, nous calculons le temps d'exécution de la fonction intégrée len(). L'initialisation de la chaîne est le code d'installation passé à l'aide de l'option s.

python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)'
100000 boucles, meilleur des 5 : 239 nsec par boucle

Dans la sortie, remarquez que nous obtenons le temps d'exécution pour le meilleur des 5 exécutions. Qu'est-ce que cela signifie ? Lorsque vous exécutez timeit en ligne de commande, l'option de répétition r est définie sur la valeur par défaut de 5. Cela signifie que l'exécution du stmt pour le nombre de fois spécifié est répétée cinq fois, et que le meilleur des temps d'exécution est renvoyé.

Analyse des méthodes d'inversion de chaînes à l'aide de timeit

Lorsque vous travaillez avec des chaînes de caractères Python, il se peut que vous souhaitiez les inverser. Les deux approches les plus courantes de l'inversion de chaînes sont les suivantes :

• Utilisation du découpage en tranches de chaînes
• Utilisation de la fonction reversed() et de la méthode join()

Inverser des chaînes Python à l'aide du découpage en tranches de chaînes

Voyons comment fonctionne le découpage en tranches de chaînes et comment vous pouvez l'utiliser pour inverser une chaîne Python. La syntaxe some-string[start:stop] renvoie une tranche de la chaîne commençant à l'indice start et s'étendant jusqu'à l'indice stop-1. Prenons un exemple.

Considérons la chaîne suivante : "Python". La chaîne est de longueur 6 et la liste des indices est de 0, 1, 2 à 5.

>>> string_1 = 'Python'

Lorsque vous spécifiez les valeurs de début et de fin, vous obtenez une tranche de chaîne qui s'étend de début à fin-1. Par conséquent, string_1[1:4] renvoie "yth".

>>> string_1 = 'Python'
>>> string_1[1:4]
'yth'

Lorsque vous ne spécifiez pas la valeur de départ, la valeur de départ par défaut de zéro est utilisée, et la tranche commence à l'index zéro et s'étend jusqu'à stop - 1.

Ici, la valeur d'arrêt est 3, de sorte que la tranche commence à l'indice 0 et va jusqu'à l'indice 2.

>>> string_1[:3]
'Pyt'

Si vous n'incluez pas l'indice d'arrêt, vous constatez que la tranche commence à l'indice de départ (1) et s'étend jusqu'à la fin de la chaîne.

>>> string_1[1 :]
'ython'

Si vous ignorez les valeurs de début et de fin, vous obtenez une tranche de la chaîne entière.

>>> string_1[: :]
'Python'

Créons une tranche avec la valeur du pas. Définissez les valeurs start, stop et step à 1, 5 et 2, respectivement. Nous obtenons une tranche de la chaîne commençant à 1 et s'étendant jusqu'à 4 (à l'exception du point final 5) contenant un caractère sur deux.

>>> string_1[1:5:2]
'yh'

Lorsque vous utilisez un pas négatif, vous pouvez obtenir une tranche commençant à la fin de la chaîne. Avec un pas de -2, string_1[5:2:-2] donne la tranche suivante :

>>> string_1[5:2:-2]
'nh'

Pour obtenir une copie inversée de la chaîne, nous ignorons les valeurs de début et de fin et fixons le pas à -1, comme indiqué :

>>> string_1[::-1]
'nohtyP'

En résumé, string[::-1] renvoie une copie inversée de la chaîne.

Inversion de chaînes de caractères à l'aide de fonctions intégrées et de méthodes de chaînes de caractères

La fonction intégrée reversed() de Python renvoie un itérateur inversé sur les éléments de la chaîne.

>>> string_1 = 'Python'
>>> reversed(string_1)
<objet inversé à 0x00BEAF70&gt

Vous pouvez donc parcourir l'itérateur inversé à l'aide d'une boucle pour:

for char in reversed(string_1) :
 print(char)

Et accéder aux éléments de la chaîne dans l'ordre inverse.

# Sortie
n
o
h
t
y
P

Ensuite, vous pouvez appeler la méthode join() sur l'itérateur inversé avec la syntaxe suivante : <sep>.join(reversed(some-string)).

L'extrait de code ci-dessous montre quelques exemples où le séparateur est un trait d'union et un espace, respectivement.

>>> '-'.join(reversed(string1))
'n-o-h-t-y-P'
>>> ' '.join(reversed(string1))
'n o h t y P'

Ici, nous ne voulons pas de séparateur ; définissez donc le séparateur à une chaîne vide pour obtenir une copie inversée de la chaîne :

>>> ''.join(reversed(string1))
'nohtyP'

L'utilisation de ''.join(reversed(some-string)) renvoie une copie inversée de la chaîne.

Comparaison des temps d'exécution avec timeit

Jusqu'à présent, nous avons appris deux approches pour inverser les chaînes de caractères Python. Mais laquelle est la plus rapide ? C'est ce que nous allons découvrir.

Dans l'exemple précédent, où nous avons chronométré des expressions Python simples, nous n'avions pas de code d'installation. Ici, nous inversons la chaîne Python. Alors que l'opération d'inversion de la chaîne s'exécute le nombre de fois spécifié par le nombre, le code d'installation est l'initialisation de la chaîne qui ne s'exécutera qu'une seule fois.

>>> import timeit
>>> timeit.timeit(stmt = 'string_1[::-1]', setup = "string_1 = 'Python'", number = 100000)
0.04951830000001678
>>> timeit.timeit(stmt = "''.join(reversed(string_1))", setup = "string_1 = 'Python'", number = 100000)
0.12858760000000302

Pour le même nombre d'exécutions de l'inversion de la chaîne donnée, l'approche par découpage de chaînes est plus rapide que l'utilisation de la méthode join() et de la fonction reversed().

Vous pouvez également lire comment inverser une liste en Python pour la faire tourner à l'envers.

Chronométrage des fonctions Python à l'aide de timeit

Dans cette section, nous allons apprendre à chronométrer les fonctions Python à l'aide de la fonction timeit. Étant donné une liste de chaînes de caractères, la fonction hasDigit suivante renvoie la liste des chaînes de caractères contenant au moins un chiffre.

def hasDigit(somelist) :
 str_with_digit = []
 for string in somelist :
 check_char = [char.isdigit() for char in string]
 if any(check_char) :
 str_with_digit.append(string)
 return str_with_digit

Nous souhaitons maintenant mesurer le temps d'exécution de cette fonction Python hasDigit() à l'aide de timeit.

Identifions d'abord l'instruction à chronométrer(stmt). Il s'agit de l'appel à la fonction hasDigit() avec une liste de chaînes de caractères comme argument. Ensuite, définissons le code d'installation. Pouvez-vous deviner ce que devrait être le code d'installation?

Pour que l'appel de la fonction s'exécute correctement, le code d'installation doit comprendre les éléments suivants :

• La définition de la fonction hasDigit()
• L'initialisation de la liste d'arguments des chaînes de caractères

Définissons le code d'installation dans la chaîne d'installation, comme indiqué ci-dessous :

setup = """
def hasDigit(somelist) :
 str_with_digit = []
 for string in somelist :
 check_char = [char.isdigit() for char in string]
 if any(check_char) :
 str_with_digit.append(string)
 return str_with_digit
thislist=['puffin3', '7frost', 'blue']
 """

Ensuite, nous pouvons utiliser la fonction timeit et obtenir le temps d'exécution de la fonction hasDigit() pour 100000 exécutions.

import timeit
timeit.timeit('hasDigit(thislist)',setup=setup,number=100000)

# Sortie
0.2810094920000097

Conclusion

Vous avez appris à utiliser la fonction timeit de Python pour chronométrer des expressions, des fonctions et d'autres éléments appelables. Cela peut vous aider à évaluer votre code, à comparer les temps d'exécution de différentes implémentations de la même fonction, et bien plus encore.

Passons en revue ce que nous avons appris dans ce tutoriel. Vous pouvez utiliser la fonction timeit() avec la syntaxe timeit.timeit(stmt=...,setup=...,number=...). Vous pouvez également exécuter timeit en ligne de commande pour chronométrer de courts extraits de code.

Dans une prochaine étape, vous pouvez explorer comment utiliser d'autres packages de profilage Python tels que line-profiler et memprofiler pour profiler votre code en termes de temps et de mémoire, respectivement.

Ensuite, apprenez à calculer la différence de temps en Python.