Recherche de site Web

Python Time.sleep Millisecondes

La méthode sleep() en Python prend du temps pour retarder l'exécution du programme en secondes. Cependant, elle peut facilement être adaptée pour fonctionner avec des millisecondes. Pour arrêter l'exécution du programme pendant un certain nombre de millisecondes, l'utilisateur peut passer le temps dans la fonction sleep() après l'avoir divisé par 1000 ou multiplié par 0,001.

Ce post abordera les méthodes pour modifier le flux d'exécution par défaut du programme et le retarder par un certain temps en millisecondes.

Méthode 1 : Temps de sommeil en millisecondes

La bibliothèque « time » fournit une fonction « sleep() » qui prend l'intervalle de délai en secondes, et le meilleur de cette fonction est qu'elle peut prendre des valeurs flottantes. Cela signifie simplement qu'elle permet aux utilisateurs de passer le temps en millisecondes également. Mais plutôt que de calculer la valeur en chiffres à virgule flottante, il est beaucoup plus pratique de prendre simplement le temps en millisecondes et ensuite soit de le diviser par 1000, soit de le multiplier par 0,001.

Syntax de la fonction sleep() avec des millisecondes :

time.sleep( MS / 1000)

Prenons un exemple pour illustrer cette méthode. Pour cela, commencez par importer la bibliothèque "time" dans votre programme en utilisant la ligne suivante :

import time

Après cela, définissez l'intervalle de temps en millisecondes :

sleepIntervalMS = 1500

print("The Program is reaching the sleep")

Passez cet intervalle de temps dans la méthode sleep() en utilisant la ligne suivante :

time.sleep(sleepIntervalMS/1000)

À la fin, après le sommeil, invitez l'utilisateur en imprimant ce qui suit :

print("This is the output after sleep")

Le code complet de cet exemple est comme suit :

import time

sleepIntervalMS = 1500

print("The Program is reaching the sleep")

time.sleep(sleepIntervalMS/1000)

print("This is the output after sleep")

Lorsque ce code est exécuté, il produit la sortie suivante dans le terminal :

Comme vous pouvez le remarquer dans le GIF ci-dessus, il y a un léger délai d'environ 1,5 secondes ou 1500 millisecondes dans l'exécution du programme.

Méthode 2 : Utilisation de Timer() du paquet Threading

Ceci est une solution alternative à la méthode sleep() du paquet temps. Ce timer() est utilisé pour exécuter une fonction après qu'une certaine période de temps (généralement en secondes) s'est écoulée. Regardez la syntaxe de la méthode Timer() donnée ci-dessous.

Syntax de la méthode Timer()

timerVar = Timer(timeInterval, functionToCall)

Dans cette syntaxe :

  • timerVar est la variable qui sera utilisée pour démarrer le compteur à l'aide de la méthode start().
  • timeInterval définira la quantité de temps à retarder avant d'appeler la fonction à l'intérieur du second argument.
  • functionToCall est la fonction qui sera appelée après le délai.

Remarque : Puisque ce post concerne la mise en veille du programme pendant un certain nombre de millisecondes, l'utilisateur peut passer le temps à la méthode Timer() après avoir divisé le temps par 1000.

Pour démontrer un exemple du fonctionnement de cette fonction, commencez par importer le package Timer de la bibliothèque threading :

from threading import Timer

Une fois cela fait, définissez la durée de l'intervalle de sommeil dans une variable :

delayMS = 2500

Définissez une fonction qui sera appelée en utilisant la méthode Timer() :

def basicPrompt():

print("This function was executed after a delay")

Appelez la méthode Timer() pour définir un minuteur sur la fonction créée ci-dessus en utilisant le délai mentionné ci-dessus également :

timeVar = Timer(delayMS/1000, basicPrompt)

Avertir l'utilisateur que le programme va entrer en veille et appeler la méthode start() de la variable Timer :

print("The program is reaching the sleep")

timeVar.start()

Le code complet de cet exemple est donné ci-dessous :

from threading import Timer
delayMS = 2500
def basicPrompt():
  print("This function was executed after a delay")
timeVar = Timer(delayMS/1000, basicPrompt)
print("The program is reaching the sleep")
timeVar.start()

Lorsque ce programme est exécuté, il produit les résultats suivants :

On peut voir dans la sortie ci-dessus que la fonction a été exécutée après deux secondes et demie ou après 2500 millisecondes. Cela conclut également ce post sur sleep() en millisecondes.

Conclusion

La méthode sleep() de Python du paquet time peut facilement être utilisée pour retarder l'exécution du programme pendant un temps défini qui est passé sous forme de millisecondes. Pour ce faire, l'utilisateur doit soit multiplier les millisecondes par ".001" soit les diviser par mille en les passant en argument de la méthode sleep. Alternativement, l'utilisateur peut également utiliser la méthode Timer(), qui a également été démontrée dans cet article.