Ce didacticiel vous apprendra à utiliser la fonction sleep () du module de temps intégré de Python pour ajouter des délais au code.
Lorsque vous exécutez un programme Python simple, l’exécution du code se déroule de manière séquentielle, une instruction après l’autre, sans délai. Cependant, vous devrez peut-être retarder l’exécution du code dans certains cas. La fonction sleep() du module de temps intégré Python vous aide à le faire.
Dans ce didacticiel, vous apprendrez la syntaxe d’utilisation de la fonction sleep() en Python et plusieurs exemples pour comprendre son fonctionnement. Commençons!
Table des matières
Syntaxe de Python time.sleep()
Le module time, intégré à la bibliothèque standard Python, fournit plusieurs fonctions utiles liées au temps. Dans un premier temps, importez le module horaire dans votre environnement de travail :
import time
Comme la fonction sleep() fait partie du module time, vous pouvez désormais y accéder et l’utiliser avec la syntaxe générale suivante :
time.sleep(n)
Ici, n est le nombre de secondes pour dormir. Il peut s’agir d’un nombre entier ou d’un nombre à virgule flottante.
Parfois, le délai requis peut être de quelques millisecondes. Dans ces cas, vous pouvez convertir la durée en millisecondes en secondes et l’utiliser dans l’appel à la fonction sleep. Par exemple, si vous souhaitez introduire un délai de 100 millisecondes, vous pouvez le spécifier à 0,1 seconde : time.sleep(0.1).
▶ Vous pouvez également importer uniquement la fonction sommeil du module horaire :
from time import sleep
Si vous utilisez la méthode ci-dessus pour l’importation, vous pouvez alors appeler la fonction sleep() directement, sans utiliser time.sleep().
Maintenant que vous avez appris la syntaxe de la fonction Python sleep(), codez des exemples pour voir la fonction en action. Vous pouvez télécharger les scripts Python utilisés dans ce didacticiel à partir du dossier python-sleep dans ce référentiel GitHub. 👩🏽💻
Retarder l’exécution du code avec sleep()
Comme premier exemple, utilisons la fonction sleep pour retarder l’exécution d’un programme Python simple.
Dans l’extrait de code suivant :
- La première instruction print() est exécutée sans délai.
- Nous introduisons ensuite un délai de 5 secondes à l’aide de la fonction sleep().
- La deuxième instruction print() ne sera exécutée qu’après la fin de l’opération de mise en veille.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")Exécutez maintenant le fichier simple_example.py et observez le résultat :
$ python3 simple_example.py
Ajouter différents délais à un bloc de code
Dans l’exemple précédent, nous avons introduit un délai fixe de 5 secondes entre l’exécution de deux instructions print(). Ensuite, codons un autre exemple pour introduire différents temps de retard lors d’une boucle dans un itérable.
Dans cet exemple, nous aimerions faire ce qui suit :
- Parcourez une phrase, accédez à chaque mot et imprimez-le.
- Après avoir imprimé chaque mot, nous aimerions attendre un certain temps avant d’imprimer le mot suivant dans la phrase.
Boucle sur une chaîne de chaînes
Considérez la chaîne, la phrase. C’est une chaîne où chaque mot est une chaîne en soi.
Si nous parcourons la chaîne, nous obtiendrons chaque caractère, comme indiqué :
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Mais ce n’est pas ce que nous voulons. Nous aimerions parcourir la phrase et accéder à chaque mot. Pour ce faire, nous pouvons appeler la méthode split () sur la chaîne de phrase. Cela renverra une liste de chaînes – obtenue en divisant la chaîne de phrase – sur toutes les occurrences d’espaces.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Boucler à travers des itérables avec différents retards
Reprenons l’exemple :
- phrase est la chaîne que nous aimerions parcourir pour accéder à chaque mot.
- delay_times est la liste des temps de retard que nous utiliserons comme argument de la fonction sleep() lors de chaque passage dans la boucle.
Ici, nous aimerions parcourir simultanément deux listes : la liste delay_times et la liste des chaînes obtenues en divisant la chaîne de phrases. Vous pouvez utiliser la fonction zip() pour effectuer cette itération parallèle.
La fonction Python zip() : zip(list1, list2) renvoie un itérateur de tuples, où chaque tuple contient l’élément à l’index i dans list1 et list2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)Sans la fonction de veille, le contrôle passerait immédiatement à l’itération suivante. Étant donné que nous avons introduit un délai, le passage suivant dans la boucle n’a lieu qu’après la fin de l’opération de mise en veille.
Exécutez maintenant delay_times.py et observez le résultat :
$ python3 delay_times.py
Les mots suivants dans la chaîne seront imprimés après un délai. Le délai après l’impression du mot à l’index i dans la chaîne est le nombre à l’index i dans la liste delay_times.
Compte à rebours en Python
Comme exemple suivant, codez un simple compte à rebours en Python.
Définissons une fonction countDown() :
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)Ensuite, analysons la définition de la fonction countDown() :
- La fonction prend un nombre n comme argument et compte à rebours jusqu’à zéro à partir de ce nombre n.
- Nous utilisons time.sleep(1) pour obtenir un délai d’une seconde entre les comptages.
- Lorsque le compte atteint 0, la fonction imprime « Prêt à partir! ».
🎯 Pour réaliser l’opération de compte à rebours, nous avons utilisé la fonction range() avec une valeur de pas négative de -1. range(n, -1, -1) nous aidera à parcourir la plage de nombres dans n, n – 1, n – 2, et ainsi de suite jusqu’à zéro. Rappelez-vous que le point final est exclu par défaut lors de l’utilisation de la fonction range().
Ajoutons ensuite un appel à la fonction countDown() avec 5 comme argument.
countDown(5)
Exécutez maintenant le script countdown.py et voyez la fonction countDown en action !
$ python3 countdown.py
Fonction de veille en multithreading
Le module de threading Python offre des fonctionnalités de multithreading prêtes à l’emploi. En Python, le Global Interpreter Lock ou GIL garantit qu’il n’y a qu’un seul thread actif en cours d’exécution à tout moment.
Cependant, pendant les opérations d’E/S et les opérations d’attente telles que la mise en veille, le processeur peut suspendre l’exécution du thread en cours et basculer vers un autre thread en attente.
Pour comprendre comment cela fonctionne, prenons un exemple.
Créer et exécuter des threads en Python
Considérez les fonctions suivantes, func1(), func2() et func3(). Ils parcourent une série de nombres et les impriment. Ceci est suivi d’une opération de mise en veille, pendant un nombre spécifique de secondes, à chaque passage dans la boucle. Nous avons utilisé différents temps de retard pour chacune des fonctions afin de mieux comprendre comment l’exécution bascule entre les threads simultanément.
import time
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)En Python, vous pouvez utiliser le constructeur Thread() pour instancier un objet thread. L’utilisation de la syntaxe threading.Thread(target = …, args = …) crée un thread qui exécute la fonction cible avec l’argument spécifié dans le tuple args.
Dans cet exemple, les fonctions func1, func2 et func3 ne prennent aucun argument. Il suffit donc de spécifier uniquement le nom de la fonction comme cible. Nous définissons ensuite les objets thread, t1, t2 et t3 avec func1, func2 et func3 comme cibles, respectivement.
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"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {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 la sortie. L’exécution change entre les trois threads. Le thread t3 a le temps d’attente le plus bas, il est donc suspendu le moins longtemps. Le thread t1 a la durée de veille la plus longue de deux secondes, c’est donc le dernier thread à terminer son exécution.
Pour en savoir plus, lisez le tutoriel sur les bases du multithreading en Python.
Conclusion
Dans ce didacticiel, vous avez appris à utiliser la fonction sleep() de Python pour ajouter des délais au code.
Vous pouvez accéder à la fonction sleep() à partir du module de temps intégré, time.sleep(). Pour retarder l’exécution de n secondes, utilisez time.sleep(n). En outre, vous avez vu des exemples de retardement des itérations suivantes dans une boucle par différentes valeurs, compte à rebours et multithreading.
Vous pouvez maintenant explorer des fonctionnalités plus avancées du module de temps. Vous voulez travailler avec des dates et des heures en Python ? En plus du module d’heure, vous pouvez tirer parti des fonctionnalités des modules datetime et calendrier.
Ensuite, apprenez à calculer le décalage horaire en Python.⏰