Comment puis-je faire un retard dans Python?


Je voudrais savoir comment mettre un délai dans un script Python.



Answers



import time
time.sleep(5)   # delays for 5 seconds. You can Also Use Float Value.

Voici un autre exemple où quelque chose est exécuté environ une fois par minute:

import time 
while True:
    print("This prints once a minute.")
    time.sleep(60)   # Delay for 1 minute (60 seconds).



Vous pouvez utiliser la fonction sleep () dans le module de temps. Il peut prendre un argument flottant pour la résolution sous-seconde.

from time import sleep
sleep(0.1) # Time in seconds.



S'il vous plaît lire https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 , qui peut vous aider plus loin:

Essayez la fonction de veille dans le module de temps.

import time
time.sleep(60)

Et mettre cela dans une boucle while et une instruction ne s'exécutera que sur la minute ... Cela vous permet d'exécuter une instruction à des intervalles prédéfinis quelle que soit la durée de la commande (tant que cela prend moins d'une minute ou 5 ou 60 ou par exemple, je voulais lancer un ping une fois par minute. Si je ne time.sleep(60) que time.sleep(60) ou time.sleep(45) , le ping ne prendra pas toujours le même temps. Voici le code :)

time.sleep(time.localtime(time.time())[5])

Le [5] tire juste les secondes hors de la valeur de retour de time.localtime() .

La grande chose à propos de time.sleep est qu'il prend en charge les nombres à virgule flottante!

import time
time.sleep(0.1) 

http://python.org/doc/current/lib/module-time.html




Un peu de plaisir avec un générateur endormi.

La question concerne le délai. Il peut s'agir d'un temps fixe, mais dans certains cas nous pourrions avoir besoin d'un délai mesuré depuis la dernière fois. Voici une solution possible:

Retard mesuré depuis la dernière fois (se réveiller régulièrement)

La situation peut être, nous voulons faire quelque chose aussi régulièrement que possible et nous ne voulons pas déranger avec toutes les last_time , next_time tout autour de notre code.

générateur de buzzer

Le code suivant ( sleepy.py ) définit buzzergen gerenarator

import time
from itertools import count

def buzzergen(period):
    nexttime = time.time() + period
    for i in count():
        now = time.time()
        tosleep = nexttime - now
        if tosleep > 0:
            time.sleep(tosleep)
            nexttime += period
        else:
            nexttime = now + period
        yield i, nexttime

Invocation de buzzergen régulier

from sleepy import buzzergen
import time
buzzer = buzzergen(3) # planning to wake up each 3 seconds
print time.time()
buzzer.next()
print time.time()
time.sleep(2)
buzzer.next()
print time.time()
time.sleep(5) # sleeping a bit longer than usually
buzzer.next()
print time.time()
buzzer.next()
print time.time()

et en cours d'exécution, nous voyons:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

Nous pouvons également l'utiliser directement dans une boucle:

import random
for ring in buzzergen(3):
    print "now", time.time()
    print "ring", ring
    time.sleep(random.choice([0, 2, 4, 6]))

et en cours d'exécution, nous pourrions voir:

now 1400102751.46
ring (0, 1400102754.461676)
now 1400102754.46
ring (1, 1400102757.461676)
now 1400102757.46
ring (2, 1400102760.461676)
now 1400102760.46
ring (3, 1400102763.461676)
now 1400102766.47
ring (4, 1400102769.47115)
now 1400102769.47
ring (5, 1400102772.47115)
now 1400102772.47
ring (6, 1400102775.47115)
now 1400102775.47
ring (7, 1400102778.47115)

Comme nous le voyons, ce buzzer n'est pas trop rigide et nous permet de rattraper régulièrement les intervalles endormis, même si nous dormons trop longtemps et sortons du programme régulier.




Comment puis-je faire un retard dans Python?

Dans un seul fil, je suggère la fonction de sommeil:

>>> from time import sleep

>>> sleep(4)

Cela suspend en fait le traitement du thread dans lequel il est appelé par le système d'exploitation, permettant à d'autres threads et processus de s'exécuter pendant qu'il dort.

Utilisez-le à cette fin, ou simplement pour retarder l'exécution d'une fonction. Par exemple:

>>> def party_time():
...     print('hooray!')
... 
>>> sleep(3); party_time()
hooray!

"Hourra!" imprimé 3 secondes après que j'ai frappé Entrée .

Exemple utilisant sleep avec plusieurs threads et processus

Encore une fois, le sleep suspend votre thread - il utilise la puissance de traitement à côté de zéro.

Pour démontrer, créez un script comme celui-ci (j'ai d'abord essayé ceci dans un shell interactif Python 3.5, mais les sous-processus ne peuvent pas trouver la fonction party_later pour une raison quelconque):

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from time import sleep, time

def party_later(kind='', n=''):
    sleep(3)
    return kind + n + ' party time!: ' + __name__

def main():
    with ProcessPoolExecutor() as proc_executor:
        with ThreadPoolExecutor() as thread_executor:
            start_time = time()
            proc_future1 = proc_executor.submit(party_later, kind='proc', n='1')
            proc_future2 = proc_executor.submit(party_later, kind='proc', n='2')
            thread_future1 = thread_executor.submit(party_later, kind='thread', n='1')
            thread_future2 = thread_executor.submit(party_later, kind='thread', n='2')
            for f in as_completed([
              proc_future1, proc_future2, thread_future1, thread_future2,]):
                print(f.result())
            end_time = time()
    print('total time to execute four 3-sec functions:', end_time - start_time)

if __name__ == '__main__':
    main()

Exemple de sortie de ce script:

thread1 party time!: __main__
thread2 party time!: __main__
proc1 party time!: __mp_main__
proc2 party time!: __mp_main__
total time to execute four 3-sec functions: 3.4519670009613037

Multithreading

Vous pouvez déclencher une fonction à appeler ultérieurement dans un thread séparé avec l'objet de thread Timer :

>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!

>>> 

La ligne vide illustre que la fonction a été imprimée à ma sortie standard et j'ai dû appuyer sur Entrée pour m'assurer que j'étais sur une invite.

L'avantage de cette méthode est que pendant que le thread Timer attendait, j'ai pu faire autre chose, dans ce cas, appuyer sur Entrée une fois - avant l'exécution de la fonction (voir la première invite vide).

Il n'y a pas d'objet respectif dans la bibliothèque multitraitement. Vous pouvez en créer un, mais il n'existe probablement pas pour une raison. Un sous-thread a beaucoup plus de sens pour un simple timer qu'un nouveau sous-processus.




La bibliothèque tkinter de la bibliothèque standard Python est un outil interactif que vous pouvez importer. Fondamentalement, vous pouvez créer des boutons et des boîtes et des popups et des choses qui apparaissent comme des fenêtres que vous manipulez avec du code.

Si vous utilisez tkinter, N'UTILISEZ PAS TIME.SLEEP() parce que votre programme sera corrompu. Cela m'est arrivé. Au lieu de cela, utilisez root.after() et remplacez les valeurs pour autant de secondes, avec un millisecondes. Par exemple, time.sleep(1) est équivalent à root.after(1000) dans tkinter.

Sinon, time.sleep() , que de nombreuses réponses ont souligné, c'est le chemin à parcourir.




Pour mettre un délai, vous devez importer le module de time . Et avec ce module, il suffit d'écrire:

time.sleep(The amount of time)

Par exemple, si vous voulez mettre un délai d'une seconde avant que l'ordinateur exécute une autre ligne, vous devez mettre:

time.sleep(1)
print('Hello World!')

C'est tout :)




Bonne question.

Vous pouvez l'obtenir en faisant simplement ceci:

from time import sleep

# doing stuff
sleep(0.5) # sleeping half a second (sleep() uses seconds, but you can also use floats)
# doing stuff..

J'espère, je pourrais aider.




les retards sont effectués avec la bibliothèque de temps , en particulier la fonction time.sleep () ...

Pour le faire attendre une seconde:

from time import sleep
sleep(1)

Cela fonctionne parce qu'en faisant:

from time import sleep

vous extrayez la fonction de veille uniquement à partir de la bibliothèque de temps, ce qui signifie que vous pouvez simplement l'appeler avec:

sleep(seconds)

plutôt que d'avoir à taper:

time.sleep()

ce qui est maladroitement long à taper.

Avec cette méthode, vous n'avez pas accès aux autres fonctionnalités de la bibliothèque de temps et vous ne pouvez pas avoir une variable appelée sleep. mais vous pouvez créer une variable appelée temps.

Faire depuis [library] import [function] (, [function2]) est super si vous voulez juste certaines parties d'un module.

Vous pouvez également le faire comme:

import time
time.sleep(1)

et vous auriez accès aux autres fonctionnalités de la bibliothèque de temps comme time.clock () tant que vous saisissez l' heure. fonctionne mais vous ne pouvez pas créer le temps variable.




Les retards peuvent être mis en œuvre en utilisant trois méthodes.

Commençons par le plus simple:

import time
time.sleep(5) #delay for 5 seconds.

La deuxième méthode à retarder utiliserait la méthode d'attente implicite.

 driver.implicitly_wait(5)

La troisième méthode est plus utile lorsque vous devez attendre qu'une action particulière soit terminée ou jusqu'à ce qu'un élément soit trouvé.

self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))



Utiliser le pygame

import pygame
pygame.init()
while True:
    pygame.time.wait(1000)
    print("This prints every second.")
    print("Please note that this method uses milliseconds.")