Ce tutoriel vous apprendra à utiliser la fonction sleep() du module temporel intégré de Python pour ajouter des délais au code.
Lorsque vous exécutez un programme Python simple, le code s’exécute séquentiellement, uneinstruction après l’autre, sans aucun délai. Cependant, vous pouvez avoir besoin de retarder l’exécution du code dans certains cas. La fonction sleep() du module de temps intégré de Python vous aide à le faire.
Dans ce tutoriel, vous apprendrez la syntaxe d’utilisation de la fonction sleep() en Python et vous découvrirez plusieurs exemples pour comprendre son fonctionnement. C’est parti !
Syntaxe de la fonction Python time.sleep()
Le module time, intégré à la bibliothèque standard de Python, fournit plusieurs fonctions utiles liées au temps. Dans un premier temps, importez le module Time dans votre environnement de travail :
import timeComme la fonction sleep() fait partie du module time, vous pouvez maintenant y accéder et l’utiliser avec la syntaxe générale suivante :
time.sleep(n) Ici, n est le nombre de secondes de sommeil. 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 ce 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 comme étant de 0,1 seconde : time.sleep(0.1).
▶ Vous pouvez également importer uniquement la fonction sleep du module time:
from time import sleepSi vous utilisez la méthode d’importation ci-dessus, vous pouvez alors appeler la fonction sleep() directement, sans utiliser time.sleep().
Maintenant que vous avez appris la syntaxe de la fonction Python sleep(), nous allons coder des exemples pour voir la fonction en action. Vous pouvez télécharger les scripts Python utilisés dans ce tutoriel à partir du dossier python-sleep dans ce repo GitHub. 👩🏽💻
Retarder l’exécution du code avec sleep()
Comme premier exemple, utilisons la fonction sleep pour retarder l’exécution d’un simple programme Python.
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 sleep.
# /python-sleep/simple_example.py
import time
print("Imprimer maintenant")
time.sleep(5)
print("Imprimer après 5 secondes de sommeil")Exécutez maintenant le fichier simple_example.py et observez la sortie :
python3 simple_example.pyAjouter 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 délais lors du passage en boucle d’un itérable.
Dans cet exemple, nous aimerions faire ce qui suit :
- Parcourir en boucle une phrase, accéder à chaque mot et l’imprimer.
- Après l’impression de chaque mot, nous souhaitons attendre un certain temps avant d’imprimer le mot suivant de la phrase.
Boucle sur une chaîne de chaînes
Considérons la chaîne de caractères phrase. Il s’agit d’une chaîne dont chaque mot est une chaîne en soi.
Si nous parcourons la chaîne en boucle, nous obtiendrons chaque caractère, comme indiqué ci-dessous :
>>> phrase = "Combien de temps cela va-t-il prendre ?"
>>> for char in sentence :
... print(char)
# Sortie (tronquée pour des raisons de lisibilité)
H
o
w
.
.
.
t
a
k
e
?Mais ce n’est pas ce que nous voulons. Nous aimerions parcourir la phrase en boucle et accéder à chaque mot. Pour ce faire, nous pouvons appeler la méthode split() sur la chaîne de la phrase. Cette méthode renverra une liste de chaînes de caractères, obtenue en divisant la chaîne de caractères de la phrase sur toutes les occurrences d’espaces blancs.
>>> phrase.split()
['How', 'long', 'will', 'this', 'take?']
>>> for word in sentence.split() :
... print(word)
# Sortie
Comment
long
ce
cette
cela prendra-t-il ?Boucle sur des tablettes avec différents délais
Reprenons l’exemple :
phraseest la chaîne de caractères que nous souhaitons parcourir en boucle pour accéder à chaque mot.delay_timesest la liste des délais que nous utiliserons comme argument de la fonctionsleep()à chaque passage dans la boucle.
Ici, nous souhaitons boucler simultanément sur deux listes : la liste delay_times et la liste des chaînes de caractères obtenues en divisant la chaîne de caractères de la phrase. 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 = "Combien de temps cela va-t-il prendre ?"
for sleep_time,word in zip(sleep_times,sentence.split()) :
print(word)
time.sleep(sleep_time)Sans la fonction sleep, la commande passerait immédiatement à l’itération suivante. Comme nous avons introduit un délai, le passage suivant dans la boucle n’a lieu qu’après la fin de l’opération sleep.
Exécutez maintenant delay_times.py et observez la sortie :
python3 delay_times.pyLes mots suivants de la chaîne seront imprimés après un certain 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
Pour l’exemple suivant, codons 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("Prêt à partir !")
else :
print(i)
time.sleep(1)Ensuite, analysons la définition de la fonction countDown():
- La fonction prend un nombre
ncomme argument et compte à rebours jusqu’à zéro à partir de ce nombren. - Nous utilisons time.sleep(1) pour obtenir un délai d’une seconde entre les décomptes.
- Lorsque le compte atteint 0, la fonction imprime “Ready to go !”.
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 à boucler sur la plage des nombres en n, n – 1, n – 2, et ainsi de suite jusqu’à zéro. Rappelez-vous que le point final est exclu par défaut lorsque vous utilisez la fonctionrange().
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.pyFonction Sleep dans le multithreading
Le module de threading de Python offre des capacités de multithreading prêtes à l’emploi. En Python, le verrouillage global de l’interprète (Global Interpreter Lock ou GIL) garantit qu’il n’y a qu’un seul thread actif en cours d’exécution à un moment donné.
Toutefois, pendant les opérations d’E/S et les opérations d’attente telles que sleep, le processeur peut suspendre l’exécution du thread en cours et passer à un autre thread en attente.
Pour comprendre comment cela fonctionne, prenons un exemple.
Création et exécution de threads en Python
Considérons les fonctions suivantes : func1(), func2() et func3(). Elles parcourent en boucle une série de nombres et les impriment. Cette opération est suivie d’une mise en veille, pendant un certain nombre de secondes, à chaque passage dans la boucle. Nous avons utilisé différents délais pour chacune des fonctions afin de mieux comprendre comment l’exécution passe d’un thread à l’autre simultanément.
import time
def func1() :
for i in range(5) :
print(f "Exécution de t1, impression de {i}.")
time.sleep(2)
def func2() :
for i in range(5) :
print(f "Exécution de t2, impression de {i}.")
time.sleep(1)
def func3() :
for i in range(4) :
print(f "Exécution de t3, impression de {i}.")
time.sleep(0.5)En Python, vous pouvez utiliser le constructeur Thread() pour instancier un objet thread. 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 threading :
# /python-sleep/threads.py
import time
import threading
def func1() :
for i in range(5) :
print(f "Exécution de t1, impression de {i}.")
time.sleep(2)
def func2() :
for i in range(5) :
print(f "Exécution de t2, impression de {i}.")
time.sleep(1)
def func3() :
for i in range(4) :
print(f "Exécution de t3, impression de {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 varie entre les trois threads. Le thread t3 a le temps d’attente le plus faible, il est donc suspendu le moins longtemps possible. Le thread t1 a la durée de sommeil la plus longue (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 tutoriel, 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). Vous avez également vu des exemples de retardement des itérations suivantes d’une boucle par différentes valeurs, de compte à rebours et de multithreading.
Vous pouvez maintenant explorer les fonctionnalités plus avancées du module time. Vous voulez travailler avec des dates et des heures en Python ? Outre le module Time, vous pouvez exploiter les fonctionnalités des modules Datetime et Calendar.