Comment puis-je faire un délai dans Python?
J'aimerais savoir comment mettre un délai dans un script Python.
import time
time.sleep(5) # Delays for 5 seconds. You can also use a 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 time . Cela peut prendre un argument float pour une résolution inférieure à une seconde.
from time import sleep
sleep(0.1) # Time in seconds
Veuillez lire this , ce qui peut vous aider davantage:
Essayez la fonction de veille dans le module de temps.
import time time.sleep(60)Et mettez ceci dans une boucle
whileet une instruction ne sera exécutée qu’à la minute ... Cela vous permet d’exécuter une instruction à des intervalles prédéfinis quel que soit le temps pris par la commande (tant que cela prend moins d’une minute). ou 5 ou 60 ou ce que vous définissez comme)) Par exemple, je voulais exécuter un ping une fois par minute. Si je ne fais quetime.sleep(60)outime.sleep(45)même, le ping ne prendra pas toujours le même temps. Voici le code :)time.sleep(time.localtime(time.time())[5])Le
[5]extrait simplement les secondes de la valeur de retour detime.localtime().Le gros avantage de
time.sleepest qu’il supporte les nombres à virgule flottante!import time time.sleep(0.1)
Comment puis-je faire un délai dans Python?
Dans un seul fil, je suggère le fonction sleep :
>>> from time import sleep
>>> sleep(4)
Cette fonction suspend en fait le traitement du thread dans lequel elle est appelée par le système d'exploitation, permettant ainsi à d'autres threads et processus de s'exécuter pendant qu'il est en veille.
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!" est imprimé 3 secondes après avoir frappé Enter.
Exemple d'utilisation de sleep avec plusieurs threads et processus
Encore une fois, sleep suspend votre thread - il utilise une puissance de traitement proche 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 __== '__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 Timerthreading :
>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!
>>>
La ligne vierge illustre le fait que la fonction est imprimée à ma sortie standard et que je devais appuyer sur Enter pour m'assurer que j'étais sur un prompt.
L’avantage de cette méthode est que pendant que le thread Timer attendait, j’ai pu faire d’autres choses, dans ce cas, frapper Enter 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 de multitraitement . Vous pouvez en créer un, mais il n'existe probablement pas pour une raison. Un sous-fil est beaucoup plus logique pour un simple timer que pour un tout nouveau sous-processus.
Un peu de plaisir avec un somnolent générateur .
La question concerne le délai. Cela peut être une heure 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 nous soucier de tout le last_time, next_time tout autour de notre code.
Générateur de sonnerie
Le code suivant ( sleepy.py ) définit un générateur buzzergen:
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
On peut aussi 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, cette sonnerie n’est pas trop rigide et nous permet de nous rattraper à des intervalles de sommeil normaux, même si nous dormons trop et sortons de notre programme habituel.
Les retards peuvent également être implémentés en utilisant les méthodes suivantes.
Première méthode
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 qu'un élément soit trouvé:
self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))
La bibliothèque tkinter dans la bibliothèque standard Python est un outil interactif que vous pouvez importer. Fondamentalement, vous pouvez créer des boutons et des zones et des popups et des choses qui apparaissent comme des fenêtres que vous manipulez avec du code.
Si vous utilisez tkinter, NE PAS UTILISER TIME.SLEEP(), car cela gâcherait votre programme. Cela m'est arrivé À la place, utilisez root.after() et remplacez les valeurs par le nombre de secondes, par millisecondes. E.g, time.sleep(1) est équivalent à root.after(1000) dans tkinter.
Sinon, time.sleep(), comme le soulignent de nombreuses réponses, qui est la voie à suivre.
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 car en faisant:
from time import sleep
Vous extrayez le fonction sleep uniquement à partir de 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 maladroit à taper.
Avec cette méthode, vous n'auriez 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 time.
Faire from [library] import [function] (, [function2]) est très bien si vous voulez seulement 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 tapez time.[function](), mais vous ne pourriez pas créer la variable time car elle écraserait le importation. Une solution à cela à faire
import time as t
ce qui vous permettrait de référencer la bibliothèque de temps comme t, vous permettant de faire:
t.sleep()
Cela fonctionne sur n'importe quelle bibliothèque.
Il y a 5 méthodes que je connais: time.sleep(), pygame.time.wait(), de matplotlib's pyplot.pause(), .after() et driver.implicitly_wait().
time.sleep() exemple (ne pas utiliser si vous utilisez Tkinter):
import time
print('Hello')
time.sleep(5) #number of seconds
print('Bye')
pygame.time.wait() exemple (non recommandé si vous n'utilisez pas la fenêtre pygame, mais que vous pouvez quitter la fenêtre instantanément):
import pygame
#If you are going to use the time module
#don't do "from pygame import *"
pygame.init()
print('Hello')
pygame.time.wait(5000)#milliseconds
print('Bye')
exemple de fonction pyplot.pause() de matplotlib (non recommandé si vous n'utilisez pas le graphique, mais vous pouvez le quitter instantanément):
import matplotlib
print('Hello')
matplotlib.pyplot.pause(5)#seconds
print('Bye')
La méthode .after() (préférable avec Tkinter):
import tkinter as tk #Tkinter for python 2
root = tk.Tk()
print('Hello')
def ohhi():
print('Oh, hi!')
root.after(5000, ohhi)#milliseconds and then a function
print('Bye')
Enfin, la méthode driver.implicitly_wait() (Selenium):
driver.implicitly_wait(5)#waits 5 seconds
La meilleure façon de retarder le temps dans Python consiste à utiliser la bibliothèque time. Comme ça:
import time
time.sleep(10)
Il suffit de remplacer 10 par le nombre de secondes que vous souhaitez retarder. Vous pouvez utiliser des formats tels que '10 .1 ',' 5.07 ', etc.
Il n'est pas recommandé de l'utiliser avec Tkinter
import time
time.sleep(1) #sleep for one second.
Exemple simple:
#After five seconds,output "hello python!!!"
import time
time.sleep(5)
print("hello python!!!")
asyncio.sleep
Notez que dans les versions récentes de python (python 3.4 ou supérieur), vous pouvez utiliser asyncio.sleep. C'est lié à la programmation asynchrone et asyncio. Découvrez l'exemple suivant:
import asyncio
from datetime import datetime
@asyncio.coroutine
def countdown(iteration_name, countdown_sec):
"""
Just count for some countdown_sec seconds and do nothing else
"""
while countdown_sec > 0:
print(f'{iteration_name} iterates: {countdown_sec} seconds')
yield from asyncio.sleep(1)
countdown_sec -= 1
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(countdown('First Count', 2)),
asyncio.ensure_future(countdown('Second Count', 3))]
start_time = datetime.utcnow()
# run both methods. How much time will both run...?
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
print(f'total running time: {datetime.utcnow() - start_time}')
Nous pouvons penser qu'il va "dormir" pendant 2 secondes pour la première méthode, puis 3 secondes dans la seconde méthode, soit un total de 5 secondes de temps d'exécution de ce code. Mais ça va imprimer:
total_running_time: 0:00:03.01286
Recommander à lire documentation officielle asyncio pour plus de détails
Si vous souhaitez mettre un délai dans le script Python:
Utilisez time.sleep ou Event().wait comme ceci:
_from threading import Event
from time import sleep
delay_in_sec = 2
# use time.sleep like this
sleep(delay_in_sec) # returns None
print(f'slept for {delay_in_sec} seconds')
# or use Event().wait like this
Event().wait(delay_in_sec) # returns False
print(f'waited for {delay_in_sec} seconds')
_Toutefois, si vous souhaitez retarder l'exécution d'une fonction, procédez comme suit:
Utilisez threading.Timer comme ceci:
_from threading import Timer
delay_in_sec = 2
def hello(delay_in_sec):
print(f'function called after {delay_in_sec} seconds')
t = Timer(delay_in_sec, hello, [delay_in_sec]) # hello function will be called 2 sec later with [delay_in_sec] as *args parameter
t.start() # returns None
print("Started")
_Les sorties:
_Started
function called after 2 seconds
_Pourquoi utiliser l'approche ultérieure?
- Est-ce que pas arrête l'exécution de tout le script. (sauf pour la fonction que vous passez)
- Après avoir démarré le chronomètre, vous pouvez également l’arrêter en effectuant
timer_obj.cancel().
Voici un exemple simple de délai:
import time
def delay(period='5'):
# If the user enters nothing, It'll wait 5 seconds
try:
#If the user not enters a int, I'll just return ''
time.sleep(period)
except:
return ''
Un autre, à Tkinter:
import tkinter
def tick():
pass
root=Tk()
delay=100 # time in milliseconds
root.after(delay,tick)
root.mainloop()
Bien que tout le monde ait suggéré le module de facto time, je pensais partager une méthode différente à l'aide de la fonction matplotlib de pyplot, pause .
Un exemple
from matplotlib import pyplot as plt
plt.pause(5) # Pauses the program for 5 seconds
Généralement, ceci est utilisé pour empêcher l'intrigue de disparaître dès qu'il est tracé ou pour faire des animations brutes.
Cela vous ferait gagner un import si vous avez déjà importé matplotlib.
vous pouvez utiliser la méthode sleep dans le paquet temporel pour retarder l'exécution du programme python
import time
time.sleep(1) # Delays for 1 seconds.
Je cherchais les réponses précédentes et je voudrais simplement me baser sur elles.
J'ai souvent voulu créer un effet de frappe, voici comment vous pouvez le faire (Python 3):
import time # For pausing
def typewrite(text):
for i in text:
print(i, end="", flush=True) # flush is True, so the result will get printed before waiting
time.sleep(0.1)
Et en Python 2:
import time, sys # Time is for pausing, sys for printing without a new line
def typewrite(text):
sys.stdout.flush() # flush is True, so the result will get printed before waiting
for i in text:
sys.stdout.write(i)
time.sleep(0.1)
J'espère que cela vous a aidé d'une certaine manière.
Si vous avez installé autopygui, vous pouvez utiliser:
#imports
import pyautogui
pyautogui._autoPause(time1,time2)
Et le temps de pause total sera de time1 * time2 secondes