¿Cómo puedo hacer un retraso de tiempo en Python?

Me gustaría saber cómo poner un retraso de tiempo en un script de Python.

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. 

Lea más aquí .

Por favor lee esto , que puede ayudarte más:

Prueba la función de dormir en el módulo de tiempo.

 import time time.sleep(60) 

Y ponga esto en un bucle de 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) o time.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 de time.localtime() .

¡Lo bueno de time.sleep es que admite números de punto flotante!

 import time time.sleep(0.1) 

Más información

¿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) 

Esta función en realidad suspende el procesamiento del subproceso en el que es llamado por el sistema operativo, permitiendo que otros subprocesos y procesos se ejecuten mientras está en suspensión.

Úselo 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!” Se imprime 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.

Un poco de diversión con un generador de sueño.

La pregunta es sobre el retraso del tiempo. Puede ser un tiempo fijo, pero en algunos casos es posible que necesitemos una demora medida 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.

La biblioteca tkinter en la biblioteca estándar de Python es una herramienta interactiva que puede importar. Básicamente, puedes crear botones, 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 progtwig. 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.

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 función de suspensión solo de la biblioteca de tiempo , lo que significa que solo puede llamarla 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 sleep . Pero podrías crear una variable llamada time .

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 tiempo como time.clock() siempre que escriba time.[function]() , pero no podría crear el tiempo variable porque sobrescribiría la importación. Una solución a esto para hacer.

 import time as t 

lo que le permitiría hacer referencia a la biblioteca de tiempos como t , permitiéndole hacer:

 t.sleep() 

Esto funciona en cualquier biblioteca.

Hay 5 métodos que conozco: time.sleep() , pygame.time.wait() , pyplot.pause() .after() , .after() y driver.implicitly_wait() .


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') 

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') 

Finalmente, el método driver.implicitly_wait() (selenium):

 driver.implicitly_wait(5)#waits 5 seconds 

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.

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')) 
 import time time.sleep(1) #sleep for one second. 

Ejemplo simple:

 #After five seconds,output "hello python!!!" import time time.sleep(5) print("hello python!!!") 

asínsico dormido

Tenga en cuenta que en las versiones más recientes de python (python 3.4 o superior) puede usar asyncio.sleep . Está relacionado con la progtwigción asíncrona y el asyncio. Mira el siguiente ejemplo:

 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}') 

Podemos pensar que se “suspenderá” durante 2 segundos para el primer método y luego 3 segundos en el segundo método, un total de 5 segundos de tiempo de ejecución de este código. Pero .. se imprimirá:

 total_running_time: 0:00:03.01286 

Recomendamos leer la documentación oficial de asyncio para más detalles.

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() 

puede usar el método de suspensión en el paquete de tiempo para retrasar la ejecución del progtwig python

 import time time.sleep(1) # Delays for 1 seconds. 

Mientras que todos los demás han sugerido el módulo de time de facto, pensé que compartiría un método diferente utilizando 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 ttwig desaparezca tan pronto como se traza o para hacer animaciones en bruto.

Esto le ahorraría una import si ya ha importado matplotlib .

Si desea poner un retardo de tiempo en el script de Python:

Use time.sleep o Event().wait así:

 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') 

Sin embargo, si desea retrasar la ejecución de una función, haga esto:

Utilice threading.Timer como este:

 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") 

Salidas:

 Started function called after 2 seconds 

¿Por qué utilizar el enfoque posterior?

  • No detiene la ejecución de todo el script. (excepto por la función que la pases)
  • Después de iniciar el temporizador, también puede detenerlo haciendo timer_obj.cancel() .

He estado buscando las respuestas anteriores y simplemente me gustaría desarrollarlas.

Muchas veces he querido crear un efecto de escritura, aquí es cómo puedes hacer esto (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) 

Y 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) 

Espero que esto te haya ayudado de alguna manera.

También puedes probar esto:

 import time #the time now start = time.time() while time.time() - start < 10: #run 1- seconds pass #do the job 

Ahora el shell no se estrellará o no reactjsrá