esperar - time.sleep python
¿Cómo puedo hacer un retraso de tiempo en Python? (12)
Me gustaría saber cómo poner un retraso de tiempo en un script de Python.
¿Cómo puedo hacer un retraso de tiempo en Python?
En un solo hilo sugiero la función dormir:
>>> from time import sleep
>>> sleep(4)
En realidad, esto suspende el procesamiento del subproceso en el que es llamado por el sistema operativo, permitiendo que otros subprocesos y procesos se ejecuten mientras duerme.
Utilícelo para ese propósito, o simplemente para demorar la ejecución de una función. Por ejemplo:
>>> def party_time():
... print(''hooray!'')
...
>>> sleep(3); party_time()
hooray!
"¡hurra!" Imprimí 3 segundos después de presionar Enter .
Ejemplo usando sleep con múltiples hilos y procesos
Una vez más, el modo de sleep suspende el hilo: utiliza una potencia de procesamiento próxima a cero.
Para demostrarlo, cree un script como este (primero intenté esto en un shell interactivo de Python 3.5, pero los subprocesos no pueden encontrar la función party_later por alguna razón):
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()
Ejemplo de salida de este 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
Multihilo
Puede activar una función para que se llame más tarde en un subproceso separado con el objeto de subprocesamiento del Timer :
>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!
>>>
La línea en blanco ilustra que la función se imprimió en mi salida estándar y tuve que presionar Intro para asegurar que estaba en un aviso.
La ventaja de este método es que mientras el subproceso del Timer estaba esperando, pude hacer otras cosas, en este caso, presionando Intro una vez, antes de que se ejecutara la función (consulte el primer indicador vacío).
No hay un objeto respectivo en la biblioteca de multiprocesamiento. Puedes crear uno, pero probablemente no exista por una razón. Un subproceso tiene mucho más sentido para un temporizador simple que un subproceso completamente nuevo.
Este es un ejemplo fácil de un retraso de tiempo:
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 ''''
Otro, en Tkinter:
import tkinter
def tick():
pass
root=Tk()
delay=100 # time in milliseconds
root.after(delay,tick)
root.mainloop()
Hay 4 métodos que conozco: time.sleep() , pygame.time.wait() , pyplot.pause() de pyplot.pause() , y .after() .
time.sleep() (no usar si usa Tkinter):
import time
print(''Hello'')
time.sleep(5) #number of seconds
print(''Bye'')
pygame.time.wait() (no recomendado si no está utilizando la ventana de pygame, pero podría salir de la ventana al instante):
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'')
Ejemplo de la función pyplot.pause() no recomendado si no está utilizando el gráfico, pero podría salir del gráfico al instante):
import matplotlib
print(''Hello'')
matplotlib.pyplot.pause(5)#seconds
print(''Bye'')
Finalmente, el método .after() (mejor con 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'')
La biblioteca tkinter en la biblioteca estándar de Python es una herramienta interactiva que puede importar. Básicamente, puedes crear botones y cuadros y ventanas emergentes y cosas que aparecen como ventanas que manipulas con el código.
Si usa tkinter, NO USE TIME.SLEEP() porque TIME.SLEEP() su programa. Esto me paso a mi En su lugar, use root.after() y reemplace los valores por muchos segundos, con milisegundos. Por ejemplo, time.sleep(1) es equivalente a root.after(1000) en tkinter.
De lo contrario, time.sleep() , que muchas respuestas han señalado, que es el camino a seguir.
La mejor manera de retrasar el tiempo en Python es usar la biblioteca de time . Me gusta esto:
import time
time.sleep(10)
Simplemente reemplaza 10 con la cantidad de segundos que quieres retrasar. Puede utilizar formatos como ''10 .1 '','' 5.07 '', etc.
No se recomienda usar esto con Tkinter.
Lea https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378 , que puede ayudarlo más:
Intente la función dormir en el módulo de tiempo.
import time time.sleep(60)Y ponga esto en un bucle while y una instrucción solo se ejecutará en el minuto ... Eso le permite ejecutar una instrucción en intervalos predefinidos sin importar cuánto demore el comando (siempre que tome menos de un minuto o 5 o 60 minutos). o lo que sea que configures para) Por ejemplo, quería ejecutar un ping una vez por minuto. Si solo
time.sleep(60)otime.sleep(45)incluso, el ping no siempre llevará la misma cantidad de tiempo. Aquí está el código :)
time.sleep(time.localtime(time.time())[5])El
[5]simplemente extrae los segundos del valor de retorno detime.localtime().Lo bueno de
time.sleepes que admite números de punto flotante.
import time time.sleep(0.1)
Los retrasos se pueden implementar utilizando tres métodos.
Comencemos con el más fácil:
import time
time.sleep(5) # Delay for 5 seconds.
El segundo método para retrasar sería usar el método de espera implícito:
driver.implicitly_wait(5)
El tercer método es más útil cuando tiene que esperar hasta que se complete una acción en particular o hasta que se encuentre un elemento:
self.wait.until(EC.presence_of_element_located((By.ID, ''UserName''))
Los retrasos se realizan con la biblioteca de tiempo , específicamente la función time.sleep() ...
Solo para hacer esperar un segundo:
from time import sleep
sleep(1)
Esto funciona porque al hacer:
from time import sleep
extrae la time.sleep() solo de la biblioteca de tiempo, lo que significa que solo puede llamar con:
sleep(seconds)
en lugar de tener que escribir
time.sleep()
que es torpemente largo para escribir.
Con este método, no obtendría acceso a las otras funciones de la biblioteca de tiempo y no puede tener una variable llamada suspensión. Pero podrías crear una variable llamada tiempo.
Hacer from [library] import [function] (, [function2]) es genial si solo quieres ciertas partes de un módulo.
Podrías hacerlo igualmente como
import time
time.sleep(1)
y tendría acceso a las otras funciones de la biblioteca de tiempos como time.clock() siempre que escriba time.[function]() , pero no pudo crear el tiempo variable.
Mientras que todos los demás han sugerido el módulo de time de facto, pensé que compartiría un método diferente usando la función pyplot , pause .
Un ejemplo
from matplotlib import pyplot as plt
plt.pause(5) # Pauses the program for 5 seconds
Normalmente, esto se utiliza para evitar que la trama desaparezca tan pronto como se traza o para hacer animaciones en bruto.
Esto le ahorraría una import si ya ha importado matplotlib .
Puede usar la función sleep() en el módulo de tiempo. Puede tomar un argumento flotante para la resolución de sub segundo.
from time import sleep
sleep(0.1) # Time in seconds.
Un poco de diversión con un generator sueño.
La pregunta es sobre el retraso del tiempo. Puede ser un tiempo fijo, pero en algunos casos podríamos necesitar un retraso medido desde la última vez. Aquí hay una posible solución:
Retraso medido desde la última vez (despertarse regularmente)
La situación puede ser, queremos hacer algo tan regularmente como sea posible y no queremos molestarnos con todas las cosas de next_time last_time , next_time todas partes de nuestro código.
Generador de zumbador
El siguiente código ( sleepy.py ) define un generador de 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
Invocando buzzergen regular
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()
Y ejecutándolo vemos:
1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47
También podemos usarlo directamente en un bucle:
import random
for ring in buzzergen(3):
print "now", time.time()
print "ring", ring
time.sleep(random.choice([0, 2, 4, 6]))
Y ejecutándolo podríamos ver:
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)
Como vemos, este timbre no es demasiado rígido y nos permite alcanzar intervalos regulares de sueño, incluso si nos quedamos dormidos y salimos del horario regular.
import time
time.sleep(5) # Delays for 5 seconds. You can also use a float value.
Aquí hay otro ejemplo donde algo se ejecuta aproximadamente una vez por minuto:
import time
while True:
print("This prints once a minute.")
time.sleep(60) # Delay for 1 minute (60 seconds).