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 produit séquentiellement—une déclaration après l'autre—sans compromis. tout retard. Cependant, vous devrez peut-être retarder l'exécution du code dans certains cas. La sleep() La fonction du module de temps intégré Python vous aide à le faire.
Dans ce didacticiel, vous apprendrez la syntaxe d'utilisation de sleep() fonction en Python et plusieurs exemples pour comprendre comment cela fonctionne. Commençons!
Syntax of Python time.sleep()
, time module, intégré à la bibliothèque standard Python, fournit plusieurs fonctions utiles liées au temps. Dans un premier temps, importez le time module dans votre environnement de travail :
import timele sleep() la fonction fait partie du time module, 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 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 sleep fonction du time module:
from time import sleepSi vous utilisez la méthode ci-dessus pour l'importation, vous pouvez alors appeler le sleep() fonctionner directement—sans utiliser time.sleep().
Maintenant que vous avez appris la syntaxe du Python sleep() fonction, codez des exemples pour voir la fonction en action. Vous pouvez télécharger les scripts Python utilisés dans ce didacticiel à partir du python-sommeil dossier dans ce référentiel GitHub. 👩🏽💻
Delay Code Execution with 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
print()l'instruction est exécutée sans délai. - On introduit alors un délai de 5 secondes en utilisant le
sleep()la fonction. - La deuxième
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")Maintenant, exécutez le simple_example.py fichier et observez la sortie :
$ python3 simple_example.py
Add Different Delays to a Code Block
Dans l'exemple précédent, nous avons introduit un délai fixe de 5 secondes entre l'exécution de deux print() déclarations. 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, sentence. 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 le split() méthode sur le sentence chaîne de caractères. Cela renverra une liste de chaînes - obtenue en divisant le sentence chaîne—sur tous occurrences d'espaces blancs.
>>> 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 :
sentenceest la chaîne que nous aimerions parcourir pour accéder à chaque mot.delay_timesest la liste des temps de retard que nous utiliserons comme argument pour lesleep()fonction lors de chaque passage dans la boucle.
Ici, nous aimerions parcourir simultanément deux listes : la delay_times list et la liste des chaînes obtenues en divisant la sentence chaîne de caractères. Vous pouvez utiliser le zip() fonction 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.
Maintenant courez delay_times.py et observez la sortie :
$ python3 delay_times.pyLes 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 le delay_times liste.
Countdown Timer in 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 du countDown() fonction:
- La fonction prend un nombre
ncomme argument et décompte jusqu'à zéro à partir de ce nombren. - 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é le
range()fonction 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 larange()la fonction.
Ajoutons ensuite un appel au countDown() fonction avec 5 comme argument.
countDown(5)Exécutez maintenant le script countdown.py et voir le countDown fonction en action !
$ python3 countdown.py
Sleep Function in Multithreading
Python filetage Le module offre des capacité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 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 Thread() constructeur pour instancier un objet thread. Utilisation de la syntaxe threading.Thread(target = …, args = …) crée un thread qui exécute le target fonction avec l'argument spécifié dans le args tuple.
Dans cet exemple, les fonctions, func1, func2 et func3, n'acceptez aucun argument. Il suffit donc de spécifier uniquement le nom de la fonction comme cible. Nous définissons ensuite des objets threads, 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 fil t3 a le temps d'attente le plus bas, il est donc suspendu le moins longtemps possible. Fil de discussion t1 a la plus longue durée de veille de deux secondes, c'est donc le dernier thread à terminer l'exécution.
Pour en savoir plus, lisez le tutoriel sur le bases du multithreading en Python.
Conclusion
Dans ce tutoriel, vous avez appris à utiliser Python sleep() fonction pour ajouter des délais au code.
Vous pouvez accéder à la sleep() fonction 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.⏰
