Pausar la ejecución en Python con time.sleep()

Vocacióntime.sleep()es la forma más rápida de pausar el código Python durante un número determinado de segundos. Para código asincrónico, useasyncio.sleep(), y para subprocesos o GUI, prefiera esperas sin bloqueo para que su aplicación siga respondiendo.

Opción 1: usar time.sleep() en código sincrónico

Paso 1:Importe el módulo de tiempo.

import time

Paso 2:Pausar la ejecución llamandotime.sleep(seconds).

print("Starting...")
time.sleep(2)  # sleep for 2 seconds
print("Done.")

Paso 3:Pase un flotador a dormir para retrasos de menos de un segundo.

time.sleep(0.1)  # 100 milliseconds

Paso 4:Inserte períodos de suspensión dentro de bucles para limitar la velocidad del trabajo, como sondeos o llamadas API.

for _ in range(5):
    print("Tick")
    time.sleep(1)

Paso 5:Evite llamartime.sleep()en el hilo principal de una GUI o dentro de un bucle de eventos asíncrono; Utilice las siguientes opciones para evitar la congelación.

Opción 2: usar asyncio.sleep() en funciones asíncronas

Paso 1:Definir una función asíncrona que esperaasyncio.sleep()en lugar de bloquear.

import asyncio

async def work():
    print("Hello ...")
    await asyncio.sleep(1)
    print("... world!")

Paso 2:Ejecute la corrutina conasyncio.run()por lo que el bucle de eventos sigue respondiendo mientras espera.

asyncio.run(work())

Paso 3:Programe varias tareas para que esperen simultáneamente para obtener un mejor rendimiento.

import asyncio

async def step(name, delay):
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    t1 = asyncio.create_task(step("A", 1))
    t2 = asyncio.create_task(step("B", 2))
    t3 = asyncio.create_task(step("C", 3))
    await t1
    await t2
    await t3

asyncio.run(main())

Opción 3: use Event.wait() para retrasos de subprocesos de respuesta

Con los subprocesos, esperar un evento hace que el cierre sea inmediato y evita esperar a que finalice el bloqueo. Ver objetos de eventos en la documentación.

Paso 1:Crear unthreading.Event()que los subprocesos de trabajo puedan esperar con un tiempo de espera.

import threading
import time

stop = threading.Event()

Paso 2:En cada trabajador, reemplacetime.sleep()constop.wait(timeout)para que el hilo pueda salir inmediatamente cuando se le indique.

def worker():
    while not stop.is_set():
        print("working...")
        # Wait up to 1s, but return early if stop is set
        stop.wait(1)

Paso 3:Inicie el hilo de trabajo y configure el evento para detenerlo limpiamente.

t = threading.Thread(target=worker, name="worker-1")
t.start()
time.sleep(3)
stop.set()
t.join()

Opción 4: programar retrasos en Tkinter sin congelar la interfaz de usuario

En Tkinter, usa el widgetafter(ms, callback)método para ejecutar el código más tarde sin bloquear el bucle de eventos. Los métodos se enumeran en la documentación de Tkinter.

Paso 1:Cree la ventana raíz y cualquier interfaz de usuario que necesite.

import tkinter as tk

root = tk.Tk()
root.geometry("300x150")

Paso 2:Programe una devolución de llamada conroot.after(delay_ms, func)en lugar de usartime.sleep().

def delayed():
    print("Ran after 2 seconds")

root.after(2000, delayed)

Paso 3:Inicie el bucle de eventos para que la interfaz de usuario permanezca interactiva mientras espera.

root.mainloop()

Consejos rápidos

time.sleep()bloquea sólo el hilo actual; otros hilos continúan ejecutándose.
Utilice flotadores durante fracciones de segundo, por ejemplotime.sleep(0.25).
Preferirasyncio.sleep()dentro del código asíncrono yEvent.wait()en servicios roscados para apagados rápidos.
En aplicaciones GUI, programe el trabajo con temporizadores (por ejemplo, Tkinterafter) para evitar ventanas congeladas.

Elija la primitiva de suspensión que coincida con su tiempo de ejecución: síncrona, asíncrona, basada en subprocesos o GUI. Obtendrá el retraso que necesita sin bloquear las partes de su aplicación que deben seguir respondiendo.