Este tutorial le enseñará cómo usar la función sleep() del módulo de tiempo incorporado de Python para agregar retrasos de tiempo al código.
Cuando ejecuta un programa simple de Python, la ejecución del código ocurre secuencialmente, una declaración tras otra, sin demora de tiempo. Sin embargo, es posible que deba retrasar la ejecución del código en algunos casos. La función sleep () del módulo de tiempo incorporado de Python lo ayuda a hacer esto.
En este tutorial, aprenderá la sintaxis del uso de la función sleep() en Python y varios ejemplos para comprender cómo funciona. ¡Empecemos!
Tabla de contenido
Sintaxis de Python time.sleep()
El módulo de tiempo, integrado en la biblioteca estándar de Python, proporciona varias funciones útiles relacionadas con el tiempo. Como primer paso, importe el módulo de tiempo a su entorno de trabajo:
import time
Como la función sleep() es parte del módulo de tiempo, ahora puede acceder y usarla con la siguiente sintaxis general:
time.sleep(n)
Aquí, n es el número de segundos para dormir. Puede ser un número entero o un número de punto flotante.
A veces, el retraso requerido puede ser de unos pocos milisegundos. En estos casos, puede convertir la duración en milisegundos a segundos y usarla en la llamada a la función de suspensión. Por ejemplo, si desea introducir un retraso de 100 milisegundos, puede especificarlo como 0,1 segundos: time.sleep(0.1).
▶ También puede importar solo la función de suspensión desde el módulo de tiempo:
from time import sleep
Si usa el método anterior para importar, puede llamar a la función sleep() directamente, sin usar time.sleep().
Ahora que ha aprendido la sintaxis de la función sleep() de Python, codifiquemos ejemplos para ver la función en acción. Puede descargar las secuencias de comandos de Python utilizadas en este tutorial desde la carpeta python-sleep en este repositorio de GitHub. 👩🏽💻
Ejecución de código de retraso con sleep ()
Como primer ejemplo, usemos la función de suspensión para retrasar la ejecución de un programa Python simple.
En el siguiente fragmento de código:
- La primera instrucción print() se ejecuta sin demora.
- Luego introducimos un retraso de 5 segundos usando la función sleep().
- La segunda declaración de impresión () se ejecutará solo después de que finalice la operación de suspensión.
# /python-sleep/simple_example.py
import time
print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")
Ahora ejecute el archivo simple_example.py y observe el resultado:
$ python3 simple_example.py
Agregar diferentes retrasos a un bloque de código
En el ejemplo anterior, introdujimos un retraso fijo de 5 segundos entre la ejecución de dos sentencias print(). A continuación, codifiquemos otro ejemplo para introducir diferentes tiempos de retraso al recorrer un iterable.
En este ejemplo, nos gustaría hacer lo siguiente:
- Recorra una oración, acceda a cada palabra e imprímala.
- Después de imprimir cada palabra, nos gustaría esperar un tiempo específico antes de imprimir la siguiente palabra de la oración.
Bucle a través de una cadena de cadenas
Considere la cadena, oración. Es una cadena donde cada palabra es una cadena en sí misma.
Si recorremos la cadena, obtendremos cada carácter, como se muestra:
>>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?
Pero esto no es lo que queremos. Nos gustaría recorrer la oración y acceder a cada palabra. Para hacer esto, podemos llamar al método split() en la cadena de oraciones. Esto devolverá una lista de cadenas, obtenidas al dividir la cadena de la oración, en todas las apariciones de espacios en blanco.
>>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?
Recorriendo iterables con diferentes retrasos
Repasemos el ejemplo:
- frase es la cadena que nos gustaría recorrer para acceder a cada palabra.
- delay_times es la lista de tiempos de retraso que usaremos como argumento para la función sleep() durante cada pasada por el bucle.
Aquí nos gustaría recorrer simultáneamente dos listas: la lista delay_times y la lista de cadenas obtenidas al dividir la cadena de oraciones. Puede usar la función zip() para realizar esta iteración paralela.
La función Python zip(): zip(list1, list2) devuelve un iterador de tuplas, donde cada tupla contiene el elemento en el índice i en list1 y list2.
# /python-sleep/delay_times.py
import time
sleep_times = [3,4,1.5,2,0.75]
sentence = "How long will this take?"
for sleep_time,word in zip(sleep_times,sentence.split()):
print(word)
time.sleep(sleep_time)
Sin la función de suspensión, el control pasaría inmediatamente a la siguiente iteración. Debido a que hemos introducido un retraso, el próximo paso a través del ciclo ocurre solo después de que se completa la operación de suspensión.
Ahora ejecute delay_times.py y observe el resultado:
$ python3 delay_times.py
Las siguientes palabras de la cadena se imprimirán después de un retraso. El retraso después de imprimir la palabra en el índice i en la cadena es el número en el índice i en la lista delay_times.
Temporizador de cuenta regresiva en Python
Como siguiente ejemplo, codifiquemos un temporizador de cuenta regresiva simple en Python.
Definamos una función countDown():
# /python-sleep/countdown.py
import time
def countDown(n):
for i in range(n,-1,-1):
if i==0:
print("Ready to go!")
else:
print(i)
time.sleep(1)
A continuación, analicemos la definición de la función countDown():
- La función toma un número n como argumento y cuenta hacia atrás hasta cero a partir de ese número n.
- Usamos time.sleep(1) para lograr un retraso de un segundo entre los conteos.
- Cuando el conteo llega a 0, la función imprime «¡Listo para funcionar!».
🎯 Para lograr la operación de cuenta regresiva, usamos la función range() con un valor de paso negativo de -1. range(n, -1, -1) nos ayudará a recorrer el rango de números en n, n – 1, n – 2, y así sucesivamente hasta cero. Recuerde que el punto final se excluye de forma predeterminada cuando se utiliza la función range().
A continuación, agreguemos una llamada a la función countDown() con 5 como argumento.
countDown(5)
¡Ahora ejecute el script countdown.py y vea la función de cuenta regresiva en acción!
$ python3 countdown.py
Función de suspensión en subprocesos múltiples
El módulo de subprocesamiento de Python ofrece capacidades de subprocesos múltiples listas para usar. En Python, Global Interpreter Lock o GIL garantiza que solo haya un subproceso activo ejecutándose en cualquier momento.
Sin embargo, durante las operaciones de E/S y las operaciones de espera, como la suspensión, el procesador puede suspender la ejecución del subproceso actual y cambiar a otro subproceso que esté esperando.
Para entender cómo funciona esto, tomemos un ejemplo.
Creación y ejecución de subprocesos en Python
Considere las siguientes funciones, func1(), func2() y func3(). Recorren un rango de números y los imprimen. A esto le sigue una operación de suspensión, durante un número específico de segundos, durante cada pasada por el bucle. Hemos utilizado diferentes tiempos de retraso para cada una de las funciones para comprender mejor cómo la ejecución cambia entre subprocesos al mismo tiempo.
import time
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
En Python, puede usar el constructor Thread() para instanciar un objeto de hilo. Utilizando la sintaxis threading.Thread(target = …, args = …) crea un subproceso que ejecuta la función de destino con el argumento especificado en la tupla args.
En este ejemplo, las funciones func1, func2 y func3 no aceptan ningún argumento. Por lo tanto, basta con especificar solo el nombre de la función como destino. Luego definimos los objetos de hilo, t1, t2 y t3 con func1, func2 y func3 como objetivos, respectivamente.
t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()
Aquí está el código completo para el ejemplo de subprocesamiento:
# /python-sleep/threads.py
import time
import threading
def func1():
for i in range(5):
print(f"Running t1, print {i}.")
time.sleep(2)
def func2():
for i in range(5):
print(f"Running t2, print {i}.")
time.sleep(1)
def func3():
for i in range(4):
print(f"Running t3, print {i}.")
time.sleep(0.5)
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)
t1.start()
t2.start()
t3.start()
Observe la salida. La ejecución se altera entre los tres subprocesos. El subproceso t3 tiene el tiempo de espera más bajo, por lo que se suspende por la menor cantidad de tiempo. El subproceso t1 tiene la duración de suspensión más larga de dos segundos, por lo que es el último subproceso en finalizar la ejecución.
Para obtener más información, lea el tutorial sobre los conceptos básicos de subprocesos múltiples en Python.
Conclusión
En este tutorial, aprendió a usar la función sleep() de Python para agregar demoras de tiempo al código.
Puede acceder a la función sleep() desde el módulo de tiempo incorporado, time.sleep(). Para retrasar la ejecución por n segundos, use time.sleep(n). Además, ha visto ejemplos de retrasos de iteraciones posteriores en un bucle por diferentes valores, cuenta regresiva y subprocesos múltiples.
Ahora puede explorar capacidades más avanzadas del módulo de tiempo. ¿Quieres trabajar con fechas y horas en Python? Además del módulo de hora, puede aprovechar la funcionalidad de los módulos de fecha y hora y calendario.
A continuación, aprende a calcular la diferencia horaria en Python.⏰