【Python time】Tutorial: Desde pausas con sleep() hasta mediciones precisas con perf_counter()

Para ejecutar Python desde el símbolo del sistema o PowerShell en tu PC, necesitas descargar e instalar Python.
Si aún no lo has hecho, consulta el artículo Instalación de Python y configuración del entorno de desarrollo para instalar Python.

¡Hola! Soy un experto que aprendió a programar con IA y lanzó dos sitios web en un mes y medio. Hace solo unos meses, era un completo principiante sin conocimientos de programación, como muchos de ustedes.

Mientras aprendes Python, ¿ves a menudo `import time` en el código generado por IA o en los ejemplos de otras personas? Quizás estés pensando, "¿Otra vez `time`, pero qué hace exactamente?" o "¿Es solo para detener y medir el tiempo?".

En este artículo, desglosaré el módulo `time` de una manera fácil de entender para principiantes, compartiendo mis propias experiencias y tropiezos. Nos centraremos específicamente en cómo "pausar un proceso (sleep)" y "medir con precisión el tiempo que toma un proceso", habilidades esenciales para escenarios prácticos como el desarrollo de sitios web y la recopilación de datos. ¡Cuando termines este artículo, serás capaz de usar el módulo `time` con total libertad!

1. ¿Por qué necesitamos manipular el tiempo? - La importancia de esperar

¿Piensas que cuanto más rápido se ejecuta un programa, mejor? En realidad, hay momentos en los que "esperar intencionadamente" es extremadamente importante. Permíteme presentarte dos casos específicos que encontré mientras desarrollaba mis sitios web.

Caso 1: Recopilación de información de sitios web (Scraping)

Cuando intentas recopilar información de un sitio web de forma automática, un programa accede a las páginas a una velocidad inimaginable para un ser humano. Esto puede provocar que una cantidad masiva de solicitudes llegue al servidor en un corto período, creando una carga pesada. Es como si una gran multitud invadiera una tienda y perturbara su funcionamiento. En el peor de los casos, tu acceso podría ser bloqueado.

Ahí es donde la técnica de "esperar" es útil. Al agregar un proceso que espera unos segundos después de acceder a una página, puedes reducir significativamente la carga del servidor y realizar la recopilación de información de manera respetuosa.

Caso 2: Uso de APIs

La gestión del tiempo también es esencial al utilizar servicios externos (APIs) que proporcionan información meteorológica o de mapas. Muchas APIs tienen límites de uso, como "hasta 60 veces por minuto" (límites de velocidad o rate limits). Si envías solicitudes que exceden este límite, el servicio puede volverse temporalmente no disponible o puedes recibir errores.

Aquí también, al "esperar" un cierto período después de cada solicitud, puedes mantenerte dentro de los límites de uso.

Este proceso de crear un "tiempo de espera" intencional en un programa se llama proceso de pausa (sleep). Y la forma más fácil de lograrlo en Python es con la función `time.sleep()`.

2. ¡Pausando perfectamente! Deteniendo la ejecución con `time.sleep()`

`time.sleep()` es una función muy simple que detiene temporalmente la ejecución del programa durante un número específico de segundos. Comencemos con su uso básico.

El siguiente código es un ejemplo simple que muestra "Iniciando el proceso." y luego, después de 3 segundos, muestra "Han pasado 3 segundos. Finalizando el proceso.". Cópialo y pégalo en tu entorno para familiarizarte con la sensación de "esperar".

# Importar el módulo time
import time

print("Iniciando el proceso.")

# Pausar el proceso por 3 segundos
time.sleep(3)

print("Han pasado 3 segundos. Finalizando el proceso.")
        

También puedes especificar decimales para el argumento, como 0.5 (0.5 segundos) o 0.1 (100 milisegundos). Esto permite un control del tiempo más preciso.

import time

print("Esperando solo 0.5 segundos.")

# Pausar el proceso por 0.5 segundos
time.sleep(0.5)

print("¡Listo!")
        

Al combinarlo con un bucle, puedes crear fácilmente un programa que ejecute algo periódicamente. Por ejemplo, aquí hay un programa que cuenta hacia atrás cada segundo.

import time

print("¡Comienza la cuenta atrás!")

for i in range(5, 0, -1):
    print(i)
    # Esperar 1 segundo
    time.sleep(1)

print("¡Despegue!")
        

3. ¡Función de cronómetro! Cómo medir el tiempo de procesamiento con precisión

Otro papel importante del módulo `time` es medir el tiempo de procesamiento. Entender qué partes de tu código están tomando más tiempo es el primer paso hacia la mejora del rendimiento.

Cuando sientas que "este proceso parece lento...", es importante medir realmente el tiempo e identificar el cuello de botella, en lugar de confiar en la intuición.

El enfoque del principiante: `time.time()`

La forma más básica de medir el tiempo es llamar a `time.time()` antes y después de un proceso y calcular la diferencia. `time.time()` devuelve el número de segundos que han pasado desde un tiempo de referencia llamado la "Época Unix" (1 de enero de 1970, 00:00:00).

import time

# Registrar el tiempo antes de que comience el proceso
start_time = time.time()

# Escribe aquí el código que quieres medir
# Como ejemplo, pongamos una pausa de 1 segundo
print("Ejecutando el proceso a medir...")
time.sleep(1)
print("Proceso completado.")

# Registrar el tiempo después de que termine el proceso
end_time = time.time()

# Calcular y mostrar el tiempo transcurrido
elapsed_time = end_time - start_time
print(f"Tiempo necesario para el proceso: {elapsed_time} segundos")
        

【Mi historia de fracaso】 La trampa de `time.time()`

En realidad, aunque `time.time()` es conveniente, tiene una gran trampa. Y es que se ve afectado por los cambios en el reloj del sistema del PC.

Cuando estaba empezando, usé `time.time()` para medir un proceso de larga duración. Sin embargo, en medio del proceso, mi PC sincronizó automáticamente su reloj (sincronización NTP), lo que resultó en una medición completamente errónea, diferente del tiempo de procesamiento real. Por ejemplo, si el reloj del sistema se retrasa 1 segundo durante el proceso, el tiempo transcurrido calculado será 1 segundo más corto. No se puede obtener una medición precisa de esa manera, ¿verdad?

Ahí es donde entra en juego un método de medición del tiempo más fiable.

El método que usan los profesionales: `time.perf_counter()`

`time.perf_counter()` (abreviatura de performance counter o contador de rendimiento) es una función especializada en medir duraciones cortas, como el tiempo de procesamiento. El valor que devuelve no es una "hora del día" específica, sino un tiempo monotónicamente creciente con la resolución más alta disponible proporcionada por el sistema operativo.

"Monotónicamente creciente" es el punto clave aquí. Significa que incluso si se cambia el reloj del sistema, el valor del contador nunca retrocederá. Por lo tanto, aunque ocurra una sincronización del reloj durante tu proceso, no afectará el resultado de la medición.

Incluso en la documentación oficial de Python, se recomienda usar `perf_counter()` para medir el tiempo de procesamiento.

El uso es exactamente el mismo que `time.time()`.

import time

# Registrar el valor del contador antes de que comience el proceso
start_counter = time.perf_counter()

# Escribe aquí el código que quieres medir
print("Ejecutando el proceso a medir...")
total = 0
for i in range(10000000): # Ejemplo de un proceso que consume tiempo
    total += i
print("Proceso completado.")

# Registrar el valor del contador después de que termine el proceso
end_counter = time.perf_counter()

# Calcular y mostrar el tiempo transcurrido
elapsed_time = end_counter - start_counter
print(f"Tiempo necesario para el proceso: {elapsed_time} segundos")
        

A menos que tengas una razón específica para no hacerlo, ¡no te equivocarás si recuerdas usar `time.perf_counter()` para medir el tiempo de procesamiento!

4. 【Avanzado】 ¡Para creadores web! Un temporizador HTML totalmente funcional

Hasta ahora, hemos aprendido sobre el módulo `time` de Python. Es muy útil para programas que se ejecutan en el lado del servidor (el backend). Sin embargo, como creador web, quieres presentar los resultados de una forma que los usuarios puedan ver, es decir, en una página web, ¿verdad?

Así que, apliquemos los conceptos del módulo `time` de Python para crear un temporizador de cuenta atrás simple que se ejecute en el navegador usando HTML y JavaScript. Así como `time.sleep(1)` de Python era una orden para "esperar 1 segundo", en JavaScript, puedes usar la orden `setInterval()` para "hacer algo cada segundo".

El siguiente código es un archivo HTML completo. Cópialo, guárdalo con un nombre como `timer.html` y ábrelo en tu navegador. Cuando presiones el botón, deberías ver que el número en la pantalla disminuye cada segundo. ¡Este es el primer paso para que los usuarios experimenten algo "que funciona"!

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Temporizador de Cuenta Atrás</title>
    <style>
        body {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #121212;
            color: #e0e0e0;
            font-family: sans-serif;
            text-align: center;
        }
        #timer-display {
            font-size: 8rem;
            font-weight: bold;
            color: #669df6;
        }
        button {
            margin-top: 2rem;
            padding: 1rem 2rem;
            font-size: 1.5rem;
            cursor: pointer;
            border: 1px solid #5f6368;
            background-color: transparent;
            color: #8ab4f8;
            border-radius: 5px;
        }
        button:disabled {
            cursor: not-allowed;
            opacity: 0.5;
        }
    </style>
</head>
<body>
    <div>
        <h1>Cuenta Atrás con JavaScript</h1>
        <div id="timer-display">10</div>
        <button id="start-btn">Iniciar</button>
        <p>¡Aplicando el concepto de time.sleep() de Python!</p>
    </div>

    <script>
        // La etiqueta script se escribe aquí
        const timerDisplay = document.getElementById('timer-display');
        const startButton = document.getElementById('start-btn');
        let timeLeft = 10;
        let timerId = null;

        function startTimer() {
            // Deshabilitar el botón para evitar doble clic
            startButton.disabled = true;

            // Ejecutar el proceso cada 1 segundo (1000 milisegundos)
            timerId = setInterval(() => {
                timeLeft--;
                timerDisplay.textContent = timeLeft;

                if (timeLeft <= 0) {
                    clearInterval(timerId); // Detener el temporizador
                    timerDisplay.textContent = "¡Ya!";
                }
            }, 1000);
        }

        // Iniciar el temporizador cuando se hace clic en el botón de inicio
        startButton.addEventListener('click', startTimer);
    </script>
</body>
</html>
        

5. Resumen de puntos a tener en cuenta al usar el módulo `time`

Finalmente, repasemos los puntos importantes a recordar cuando se trabaja con el módulo `time`.

• Usa `time.sleep()` para pausar: Úsalo cuando quieras pausar intencionadamente un proceso, como cortesía en el web scraping o al usar APIs.
• Usa `time.perf_counter()` para medir el tiempo: Úsalo cuando quieras medir con precisión el rendimiento de un proceso. Es más fiable que `time.time()` porque no se ve afectado por los cambios del reloj del sistema.
• La precisión de `sleep()` no es perfecta: Incluso con `time.sleep(1)`, dependiendo del estado de otros procesos del sistema operativo, el tiempo de espera real podría ser de 1.002 segundos o 1.01 segundos en lugar de exactamente 1.000 segundos. Recuerda que no es adecuado para un control de ultra alta precisión.

Conclusión

En este artículo, hemos aprendido a "pausar" y "medir" procesos usando el módulo `time` de Python. Puede parecer un módulo modesto a primera vista, pero es una herramienta indispensable y muy poderosa para crear programas prácticos.

Específicamente, `time.sleep()` es una función importante para mostrar consideración hacia otros (servidores), mientras que `time.perf_counter()` es para mostrar consideración hacia ti mismo (mejorando el rendimiento del código).

Intenta incorporar el concepto de "tiempo" en tus programas usando lo que has aprendido hoy. Estoy seguro de que ampliará enormemente la gama de cosas que puedes crear.