Utiliser Python Timeit pour chronométrer votre code

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

La synchronisation de votre code peut vous aider à obtenir une estimation du temps d’exécution d’un morceau de code et également à identifier les sections du code qui doivent être optimisées.

Nous allons commencer par apprendre la syntaxe de la fonction timeit de Python. Et puis nous coderons 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 Python timeit

Le module timeit fait partie de la bibliothèque standard 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 transmettre le nom de l’appelable.
  • Comme son nom l’indique, la configuration désigne le morceau de code qui ne doit être exécuté qu’une seule fois, souvent comme condition préalable à l’exécution du stmt. Par exemple, supposons que vous calculiez le temps d’exécution pour la création d’un tableau NumPy. Dans ce cas, l’importation de numpy est le code de configuration et la création réelle est l’instruction à chronométrer.
  • Le numéro de paramètre indique le nombre de fois que le stmt est exécuté. La valeur par défaut de number est 1 million (1000000), mais vous pouvez également définir ce paramètre sur toute autre valeur de votre choix.

Maintenant que nous avons appris la syntaxe pour utiliser la fonction timeit(), commençons à coder quelques exemples.

Synchronisation des 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 un 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 de plancher pour 10 000 et 100 000 exécutions.

Notez que nous transmettons l’instruction à chronométrer en tant que chaîne Python et utilisons un point-virgule pour séparer les différentes expressions dans 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 sur la ligne de commande. Voici l’équivalent en ligne de commande de l’appel de la fonction timeit :

$ python-m timeit -n [number] -s [setup] [stmt]
  • python -m timeit indique que nous exécutons timeit comme module principal.
  • n est une option de ligne de commande qui indique le nombre de fois que le code doit s’exécuter. Cela équivaut à l’argument nombre 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 loops, best of 5: 35.8 nsec per loop

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 de configuration transmis à l’aide de l’option s.

$ python -m timeit -n 100000 -s "string_1 = 'coding'" 'len(string_1)'
100000 loops, best of 5: 239 nsec per loop

Dans la sortie, notez que nous obtenons le temps d’exécution pour la meilleure des 5 exécutions. Qu’est-ce que ça veut dire? Lorsque vous exécutez timeit sur la 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 de stmt pour le nombre de fois spécifié est répétée cinq fois et que la meilleure des durées d’exécution est renvoyée.

Analyse des méthodes d’inversion de chaîne à l’aide de timeit

Lorsque vous travaillez avec des chaînes Python, vous souhaiterez peut-être les inverser. Les deux approches les plus courantes de l’inversion de chaîne sont les suivantes :

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

Inverser les chaînes Python à l’aide du découpage de chaînes

Voyons comment fonctionne le découpage de chaîne et comment vous pouvez l’utiliser pour inverser une chaîne Python. Utilisation de la syntaxe une chaîne[start:stop] renvoie une tranche de la chaîne commençant au début de l’index et s’étendant jusqu’à l’index stop-1. Prenons un exemple.

Considérez la chaîne suivante ‘Python’. La chaîne est de longueur 6 et la liste des indices est de 0, 1, 2 jusqu’à 5.

>>> string_1 = 'Python'

Lorsque vous spécifiez à la fois les valeurs de début et de fin, vous obtenez une tranche de chaîne qui s’étend du début à l’arrêt-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’à l’arrêt – 1.

Ici, la valeur d’arrêt est 3, donc la tranche commence à l’index 0 et monte jusqu’à l’index 2.

>>> string_1[:3]
'Pyt'

Lorsque vous n’incluez pas l’index d’arrêt, vous voyez que la tranche commence à partir de l’index de début (1) et s’étend jusqu’à la fin de la chaîne.

>>> string_1[1:]
'ython'

Ignorer les valeurs de début et de fin renvoie une tranche de la chaîne entière.

>>> string_1[::]
'Python'

Créons une tranche avec la valeur de pas. Définissez les valeurs de démarrage, d’arrêt et de pas sur 1, 5 et 2, respectivement. Nous obtenons une tranche de la chaîne commençant à 1 s’étendant jusqu’à 4 (à l’exclusion du point final 5) contenant un caractère sur deux.

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

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

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

Donc, pour obtenir une copie inversée de la chaîne, nous ignorons les valeurs de début et de fin et définissons le pas sur -1, comme indiqué :

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

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

Inversion de chaînes à l’aide de fonctions intégrées et de méthodes de chaîne

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

>>> string_1 = 'Python'
>>> reversed(string_1)
<reversed object at 0x00BEAF70>

Vous pouvez donc parcourir l’itérateur inverse à l’aide d’une boucle for :

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

Et accédez aux éléments de la chaîne dans l’ordre inverse.

# Output
n
o
h
t
y
P

Ensuite, vous pouvez ensuite appeler la méthode join() sur l’itérateur inverse avec la syntaxe : .join(reversed(some-string)).

L’extrait de code ci-dessous montre quelques exemples où le séparateur est un tiret 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 aucun séparateur ; définissez donc le séparateur sur 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 à l’aide de timeit

Jusqu’à présent, nous avons appris deux approches pour inverser les chaînes Python. Mais lequel d’entre eux est le plus rapide ? Découvrons-le.

Dans un exemple précédent où nous avons chronométré des expressions Python simples, nous n’avions pas de code de configuration. Ici, nous inversons la chaîne Python. Alors que l’opération d’inversion de chaîne s’exécute le nombre de fois spécifié par le nombre, le code de configuration 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 pour inverser la chaîne donnée, l’approche de découpage de chaîne est plus rapide que l’utilisation de la méthode join() et de la fonction reversed().

Synchronisation des fonctions Python à l’aide de timeit

Dans cette section, apprenons à chronométrer les fonctions Python avec la fonction timeit. Étant donné une liste de chaînes, la fonction suivante hasDigit renvoie la liste des chaînes 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 aimerions maintenant mesurer le temps d’exécution de cette fonction Python hasDigit() en utilisant timeit.

Identifions d’abord l’instruction à chronométrer (stmt). C’est l’appel à la fonction hasDigit() avec une liste de chaînes 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 fonction s’exécute correctement, le code d’installation doit inclure les éléments suivants :

  • La définition de la fonction hasDigit()
  • L’initialisation de la liste d’arguments des chaînes

Définissons le code de configuration dans la chaîne de configuration, 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 100 000 exécutions.

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

Conclusion

Vous avez appris à utiliser la fonction timeit de Python pour chronométrer des expressions, des fonctions et d’autres callables. Cela peut vous aider à comparer votre code, à comparer les temps d’exécution de différentes implémentations de la même fonction, etc.

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=…). Alternativement, vous pouvez exécuter timeit sur la ligne de commande pour chronométrer les extraits de code court.

Dans une prochaine étape, vous pouvez explorer comment utiliser d’autres packages de profilage Python comme line-profiler et memprofiler pour profiler votre code pour le temps et la mémoire, respectivement.

Ensuite, apprenez à calculer le décalage horaire en Python.

x