En utilisant la méthode de sommeil Python

Si vous souhaitez définir un délai avant d'exécuter un script, vous pouvez utiliser le dormir() fonction qui est intégrée à Python. Cette méthode existe sous le temps module. Généralement, la fonction Sleep () est utilisée pour arrêter l'exécution du programme pour la période donnée (en secondes). Par exemple, si vous téléchargez un fichier à partir d'un emplacement à l'aide d'un script qui peut nécessiter une certaine période de temps, vous pouvez utiliser la méthode Sleep () pour informer l'utilisateur d'attendre. Ce tutoriel vous montrera certaines des différentes utilisations de la fonction Sleep () dans Python 3.

Syntaxe

L'exemple suivant montre l'utilisation simple de la fonction Sleep () pour arrêter l'exécution du programme au milieu du script pendant une certaine période. Le script lira et imprimera la valeur du temps du système actuel, attendra 5 secondes sous la fonction Sleep (), et lisez à nouveau et imprimez l'heure du système actuel. Ici, les fonctions localtime () et time () sont utilisées pour lire la date et l'heure du système actuelles, et la fonction strftime () est utilisée pour imprimer l'heure formatée.

#!/ usr / bin / env python3
# Module d'heure d'importation
heure d'importation
# Lisez la date et l'heure actuelles
maintenant = temps.Time local (temps.temps())
# Imprimer l'heure de début
imprimer (heure.Strftime ("L'heure de début:% H:% M:% S", maintenant))
# Attendre 5 secondes
imprimer ("en attente de 5 secondes ...")
temps.sommeil (5)
# Lisez la date et l'heure actuelles
maintenant = temps.Time local (temps.temps())
# Temps de fin d'impression
imprimer (heure.Strftime ("The End Time:% h:% m:% s", maintenant))

Sortir

La sortie suivante apparaîtra après avoir exécuté le script ci-dessus. La sortie montre que la durée entre l'heure de début et l'heure de fin est de 5 secondes, en utilisant la fonction Sleep ().

Exemple 2: Créez un compteur de temps en utilisant le sommeil ()

L'exemple suivant montre comment créer facilement un compteur de temps via la méthode Sleep (). Le script prendra un nombre en secondes pour initialiser la variable de contre-le-temps. Trois modules sont importés ici. Le DateTime Le module est importé pour définir la valeur de temps initiale. Le temps Le module est importé pour utiliser la fonction Sleep (). Le système Le module est utilisé pour terminer l'infini pendant la boucle lorsque la valeur du comptoir est égale à la valeur de compteur temporel. Quatre variables sont utilisées dans le script pour initialiser les variables heure, minute, deuxième et comptoir pour définir l'heure de départ du compteur de temps. Ici, la fonction Sleep () attendra une seconde dans chaque itération de la boucle, puis imprimera la valeur du compteur de temps.

#!/ usr / bin / env python3
# Importer le module DateTime
Importer DateTime
# Module d'heure d'importation
heure d'importation
# Importer le module sys
importer sys
# Prenez le nombre de secondes à compter
timer = int (entrée ("définir la valeur du compteur en secondes:"))
# Initialiser le temps et la valeur de comptoir à 0
heure = minute = seconde = compteur = 0
# Imprimez la valeur de la minuterie de départ
Imprimer (DateTime.heure (heure, minute, deuxième))
essayer:
# Définir une boucle infinie
Bien que vrai:
# Retard pour 1 seconde
temps.sommeil (1)
# Compteur d'incrément par 1
compteur = compteur + 1
# Incrément deuxième par 1
seconde = seconde + 1
# Imprimez la valeur de temporisation actuelle
Imprimer (DateTime.heure (heure, minute, deuxième))
# Définissez la deuxième valeur sur 0 lorsque la valeur est supérieure à 60
Si deuxième> 60:
minute = minute + 1
seconde = 0
# Réglez la valeur minute sur 0 lorsque la valeur est supérieure à 60
Si minute> 60:
heure = heure + 1
minute = 0
# Terminer la boucle lorsque la valeur du compteur est égale à la valeur du temporisateur
Si compteur == minuterie:
Imprimer ("Temps terminé.")
casser
sauf le clavier Interrupteur:
# Terminer le script lorsque Ctrl + C est enfoncé
système.sortie

Sortir

La sortie suivante apparaîtra après l'exécution du script.

Exemple 3: Imprimez chaque caractère d'une chaîne avec un retard

Si vous souhaitez afficher chaque caractère d'un texte avec un certain retard dans la sortie, vous pouvez appliquer la fonction Sleep () dans le script. Une tâche similaire est montrée dans le script suivant. Ici, une valeur de texte est prise comme l'entrée. Chaque caractère du texte est itéré à l'aide de la boucle et la fonction attendra 0.4 secondes avant d'imprimer.

#!/ usr / bin / env python3
# Module d'heure d'importation
heure d'importation
# Prendre une valeur de chaîne
name = entrée ("Entrez votre nom:")
# Itérer la boucle pour lire chaque personnage de la chaîne
pour Val dans le nom:
# Imprimez chaque personnage sans Newline
imprimer (val, end = ")
# Attendre 0.4 secondes après l'impression de chaque personnage
temps.sommeil (0.4)

Sortir

Exécutez le script. Vous comprendrez correctement la sortie après l'exécution du script.

Exemple 4: Utilisation du sommeil () dans un script multithread

L'exemple suivant montre l'utilisation de la fonction Sleep () dans le script python multithread. Deux modules sont importés ici: le module de temps pour l'utilisation de la fonction Sleep () et le module de threading pour créer plusieurs threads. Deux fonctions personnalisées sont utilisées dans le script. Un message texte imprimera et attendra 0.5 secondes pendant trois fois à l'intérieur de la boucle pour le premier thread commence. Un message texte imprimera et attendra 1 Deuxièmement pour quatre fois à l'intérieur de la boucle pour le deuxième thread commence.

#!/ usr / bin / env python3
# Module d'heure d'importation
heure d'importation
# Importer le module de threading
Filation d'importation
# Définir la première fonction de thread
def PRN_MESSAGE_1 ():
pour n à portée (3):
Imprimer ("Imprimer Thread 1 Message")
temps.sommeil (0.5)
# Définir la deuxième fonction de thread
def PRN_MESSAGE_2 ():
pour n à portée (4):
Imprimer ("Imprimer Thread 2 Message")
temps.sommeil (1)
# Définissez la première fonction de thread
thread1 = filetage.Thread (cible = PRN_Message_1)
# Démarrez la première fonction de thread
thread1.commencer()
# Définissez la deuxième fonction de thread
thread2 = filetage.Thread (cible = prn_message_2)
# Démarrez la deuxième fonction de thread
thread2.commencer()

Sortir

La sortie suivante apparaîtra après l'exécution du script. Après avoir commencé le premier fil, le deuxième fil commence et attend jusqu'à l'achèvement pendant 1 seconde. Pendant ce temps, la boucle du premier fil est terminée les deux dernières itérations. Les trois dernières sorties sont apparues pour la boucle du deuxième thread.

Conclusion

La fonction Sleep () est utilisée pour résoudre de nombreux types différents de problèmes liés au temps dans Python. Diverses utilisations de cette méthode sont expliquées en utilisant des exemples très faciles ici pour aider le lecteur à connaître les fonctions de cet outil. Je crois que vous ou tout autre utilisateur Python pourrez utiliser correctement cette méthode après avoir pratiqué les exemples inclus dans ce tutoriel.