Comment ajouter des retards au code
Ce guide vous expliquera comment utiliser la fonction sleep() du module temporel de Python pour introduire des pauses dans l'exécution de votre code.
Lorsqu'un programme Python est exécuté, le code est traité séquentiellement, instruction par instruction, sans interruption. Cependant, il est parfois nécessaire de ralentir ce processus. La fonction sleep() du module time de Python est conçue pour cela.
Dans ce tutoriel, vous découvrirez la syntaxe pour utiliser la fonction sleep() en Python, ainsi que divers exemples concrets pour mieux comprendre son fonctionnement. Entamons ce voyage !
La syntaxe de time.sleep() en Python
Le module time, intégré à Python, offre un ensemble de fonctions utiles liées au temps. Pour commencer, importez ce module dans votre environnement de travail :
import time
Puisque la fonction sleep() fait partie de ce module, vous pouvez désormais l'utiliser avec la syntaxe suivante :
time.sleep(n)
Ici, n représente le nombre de secondes pendant lesquelles le programme doit "dormir". Cette valeur peut être un entier ou un nombre décimal.
Dans certains cas, le délai requis peut être de quelques millisecondes. Pour cela, convertissez la durée en millisecondes en secondes. Par exemple, pour un délai de 100 millisecondes, utilisez time.sleep(0.1), car 100 millisecondes équivalent à 0.1 seconde.
▶ Vous pouvez également choisir d'importer uniquement la fonction sleep du module time :
from time import sleep
Dans ce cas, vous pouvez appeler la fonction sleep() directement, sans utiliser time.sleep().
Maintenant que vous maîtrisez la syntaxe de sleep(), explorons quelques exemples pratiques. Vous pouvez télécharger les scripts Python utilisés dans ce tutoriel depuis le dossier python-sleep de ce dépôt GitHub. 👩🏽💻
Ralentir l'exécution du code avec sleep()
Commençons par un exemple simple d'utilisation de sleep() pour ralentir l'exécution d'un programme Python.
Dans l'extrait de code suivant :
- La première instruction
print()est exécutée sans délai. - Ensuite, on insère une pause de 5 secondes avec
sleep(). - La deuxième instruction
print()ne sera exécutée qu'après cette pause.
# /python-sleep/simple_example.py
import time
print("Affichage immédiat")
time.sleep(5)
print("Affichage après 5 secondes d'attente")
Exécutez le fichier simple_example.py et observez le résultat :
$ python3 simple_example.py
Ajouter des pauses variées dans un bloc de code
L'exemple précédent utilisait une pause fixe de 5 secondes entre deux instructions print(). Voyons maintenant comment introduire des pauses de durées différentes lors d'une boucle.
L'objectif est de :
- Parcourir une phrase, accéder à chaque mot et l'afficher.
- Après chaque affichage, attendre un certain temps avant d'afficher le mot suivant.
Parcourir une chaîne de caractères
Considérez une chaîne de caractères, par exemple une phrase. Il s'agit d'une chaîne où chaque mot est également une chaîne.
Si vous parcourez la chaîne directement, vous accéderez à chaque caractère, comme ceci :
>>> phrase = "Quel temps fera-t-il ?" >>> for char in phrase: ... print(char) # Résultat (tronqué) Q u e l . . . - i l ?
Ce n'est pas ce que nous voulons. Nous voulons accéder à chaque mot. Pour cela, nous utilisons la méthode split() sur la chaîne phrase. Elle retourne une liste de chaînes, obtenue en divisant la phrase à chaque espace.
>>> phrase.split() ['Quel', 'temps', 'fera-t-il', '?'] >>> for mot in phrase.split(): ... print(mot) # Résultat Quel temps fera-t-il ?
Parcourir des itérables avec des pauses variables
Reprenons notre exemple :
phraseest la chaîne que nous voulons parcourir pour accéder à chaque mot.delaisest la liste des durées de pause que nous utiliserons avec la fonctionsleep()à chaque itération.
Nous voulons parcourir simultanément deux listes : la liste delais et la liste de mots obtenue après la séparation de la phrase. Pour cela, nous utilisons la fonction zip().
La fonction zip(liste1, liste2) retourne un itérateur de tuples, où chaque tuple contient l'élément à l'index i de liste1 et de liste2.
# /python-sleep/delay_times.py
import time
delais = [3,4,1.5,2,0.75]
phrase = "Quel temps fera-t-il ?"
for delai, mot in zip(delais, phrase.split()):
print(mot)
time.sleep(delai)
Sans sleep(), l'itération suivante démarrerait immédiatement. Avec sleep(), l'itération suivante ne débute qu'après la pause.
Exécutez delay_times.py et observez le résultat :
$ python3 delay_times.py
Chaque mot sera affiché après une pause. La pause après l'affichage du mot à l'index i correspond à la valeur à l'index i de la liste delais.
Compte à rebours en Python
Voici un exemple de code de compte à rebours.
Définissons la fonction compte_a_rebours() :
# /python-sleep/countdown.py
import time
def compte_a_rebours(n):
for i in range(n,-1,-1):
if i==0:
print("Prêt au décollage!")
else:
print(i)
time.sleep(1)
Décortiquons le code de compte_a_rebours():
- La fonction prend un nombre
nen argument et décompte jusqu'à zéro. time.sleep(1)introduit une pause d'une seconde entre chaque affichage.- Quand le décompte atteint 0, la fonction affiche "Prêt au décollage!".
🎯 Pour le décompte, nous utilisons range() avec un pas négatif de -1. range(n, -1, -1) génère une séquence de nombres de n à 0, en décrémentant de 1 à chaque fois. N'oubliez pas que la valeur de fin est exclue lors de l'utilisation de range().
Ajoutons maintenant un appel à la fonction compte_a_rebours() avec 5 en argument.
compte_a_rebours(5)
Exécutez le script countdown.py et observez la fonction compte_a_rebours en action !
$ python3 countdown.py
sleep() et le multithreading
Le module threading de Python propose des outils pour le multithreading. En Python, le Verrou Global de l'Interpréteur (GIL) garantit qu'un seul thread est actif à un instant donné.
Cependant, lors d'opérations d'E/S et d'attente, comme les pauses de type sleep(), le processeur peut suspendre le thread en cours et passer à un autre thread en attente.
Pour comprendre ce fonctionnement, prenons un exemple.
Créer et exécuter des threads en Python
Considérez les fonctions func1(), func2() et func3(). Elles parcourent une séquence de nombres et les affichent. Elles sont suivies d'une pause sleep(), d'une durée spécifique, à chaque itération. Nous avons utilisé des durées différentes pour chaque fonction afin de mieux observer le changement de contexte entre les threads.
import time
def func1():
for i in range(5):
print(f"Exécution t1, affichage {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Exécution t2, affichage {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Exécution t3, affichage {i}.")
time.sleep(0.5)
En Python, vous pouvez utiliser le constructeur Thread() pour créer un objet thread. La syntaxe threading.Thread(target = ..., args = ...) crée un thread qui exécute la fonction cible, avec les arguments spécifiés dans le tuple args.
Dans cet exemple, les fonctions func1, func2 et func3 ne prennent pas d'arguments. On précise donc simplement le nom de la fonction comme cible. On définit ensuite les threads t1, t2 et t3, avec func1, func2 et func3 comme cibles respectives.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Voici le code complet de l'exemple de thread :
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Exécution t1, affichage {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Exécution t2, affichage {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Exécution t3, affichage {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Observez le résultat. L'exécution alterne entre les trois threads. Le thread t3 a le temps d'attente le plus court, il est donc suspendu le moins longtemps. Le thread t1 a la pause la plus longue de deux secondes, il est donc le dernier à terminer son exécution.
Pour en savoir plus, lisez ce tutoriel sur les bases du multithreading en Python.
Conclusion
Dans ce tutoriel, vous avez appris à utiliser la fonction sleep() de Python pour introduire des pauses dans le code.
La fonction sleep() est accessible depuis le module time via time.sleep(). Pour retarder l'exécution de n secondes, utilisez time.sleep(n). Vous avez également vu des exemples concrets avec des pauses variables dans des boucles, un compte à rebours et le multithreading.
Vous pouvez maintenant explorer d'autres fonctionnalités du module time. Vous souhaitez travailler avec des dates et des heures en Python ? En plus du module time, vous pouvez profiter des modules datetime et calendar.
Ensuite, apprenez comment calculer les décalages horaires en Python. ⏰