Medición de rendimiento de código con Timeit en Python

Curso de Python Avanzado para Arquitectura de Proyectos y PyPI

Contenido del curso

Calidad de Código: Automatización y Validación

Rendimiento medición de velocidad y memoria

Programación concurrente con asyncio

Distribución y empaquetamiento

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:19

Medición de rendimiento de código con Timeit en Python

Curso de Python Avanzado para Arquitectura de Proyectos y PyPI

Clase 10 de 17

Clase 10 / 17

Recursos

Las intuiciones engañan: para escribir código rápido hay que medir. Con timeit en Python podrás evaluar tiempos de ejecución de forma práctica y comparar implementaciones reales. Además, repasarás qué expresa la notación Big O sobre escalabilidad en el peor escenario, para decidir con criterio dónde optimizar.

¿Cómo medir rendimiento en Python con timeit?

Para comparar enfoques, crea dos funciones que hagan lo mismo y mide varias veces. Así identificas diferencias reales de desempeño y evitas suposiciones.

¿Cómo preparar las funciones a comparar?

Define un tamaño grande para notar diferencias y valida que ambas funciones produzcan el mismo resultado.

# archivo: timing_pruebas.py
numero = 10_000_000

def suma_con_sum():
    return sum(range(numero))

def suma_con_for():
    total = 0
    for i in range(numero):
        total += i
    return total

print(f"¿Son iguales? {suma_con_sum() == suma_con_for()}")  # True

Puntos clave:

Usa el mismo dato de entrada para ambas funciones.
Verifica la igualdad antes de medir con print.
Mantén el código simple y legible.

¿Cómo ejecutar timeit y formatear resultados?

Configura un número de repeticiones para obtener una medición estable. timeit ejecuta la función varias veces y devuelve un tiempo útil para comparar.

import timeit

repeticiones = 10  # menos repeticiones = resultados más rápidos de ver

tiempo_sum = timeit.timeit(suma_con_sum, number=repeticiones)
tiempo_for = timeit.timeit(suma_con_for, number=repeticiones)

print(f"Tiempo para sum: {tiempo_sum:.6f}s")
print(f"Tiempo para for: {tiempo_for:.6f}s")

Detalles importantes:

Usa el parámetro number para indicar cuántas veces se llama cada función.
Formatea con :.6f para ver diferencias pequeñas con claridad.
Compara valores en el mismo formato.

¿Cómo interpretar los resultados?

En la práctica observamos que sum(range(...)) es más rápido que un for tradicional en Python: el primero puede quedar por debajo de un segundo, mientras que el for ronda alrededor de 1.6 segundos en la misma escala de datos. Con esto, ya puedes elegir la implementación más eficiente para cargas grandes.

¿Qué es la notación Big O y por qué importa?

La notación Big O describe cómo crece el tiempo o la memoria de un algoritmo a medida que aumenta el tamaño de la entrada. Se enfoca en el peor caso, no es una medida exacta, pero sí una guía para comparar eficiencia y escalabilidad entre alternativas. Con este criterio sabrás si un algoritmo se volverá muy lento o consumirá demasiada memoria cuando procese muchos datos.

Conceptos clave:

Complejidad algorítmica: relación entre tamaño de entrada y recursos usados.
Peor escenario: caso que más tarda o más memoria usa.
Comparación relativa: orienta decisiones sin depender de tiempos absolutos.

¿Qué buenas prácticas y qué reto aplicar ya?

Mide con método y toma decisiones informadas. Así mejoras rendimiento sin sacrificar claridad.

Buenas prácticas:

Elige un number apropiado: más repeticiones, más precisión.
Separa el setup del código a medir.
Mide varias veces y calcula promedios.
Considera rendimiento y legibilidad.
No optimices prematuramente: primero mide.

Reto práctico:

Revisa las funciones del proyecto y detecta cuáles requieren ajuste de rendimiento.
Usa timeit para medir cuánto tarda cada método o funcionalidad.
Propón mejoras para hacerlas más rápidas y comparte tus ajustes en los comentarios.

¿Ya comparaste tus funciones con timeit? Cuéntame qué mejoras aplicaste y qué diferencias de tiempo encontraste.

Gabriel Obregón

Hace un año

🎯Rendimiento en Python & Big O

🔍 1. Idea clave

💡 Medir > Intuir

· Las suposiciones engañan.

· timeit = herramienta para medir y comparar código real.

· Big O = brújula para entender la escalabilidad.

⚙️ 2. Midiendo rendimiento con timeit

🛠️ Preparación

1️⃣ Crea funciones equivalentes

2️⃣ Usa datos grandes

3️⃣ Comprueba que producen el mismo resultado

📘 Ejemplo

numero = 10_000_000

def suma_con_sum():

return sum(range(numero))

def suma_con_for():

total = 0

for i in range(numero):

total += i

return total

print(suma_con_sum() == suma_con_for()) # True

⏱️ 3. timeit paso a paso

▶️ Cómo ejecutar

import timeit

repeticiones = 10

tiempo_sum = timeit.timeit(suma_con_sum, number=repeticiones)

tiempo_for = timeit.timeit(suma_con_for, number=repeticiones)

print(f"Tiempo sum: {tiempo_sum:.6f}s")

print(f"Tiempo for: {tiempo_for:.6f}s")

🔑 Claves visuales

📌 number → cuántas veces se ejecuta

📌 .6f → precisión para ver diferencias

📌 Mismos datos = comparación justa

📈 4. Lectura de resultados

⚡ Tendencia real:

sum(range(...)) → más rápido

for manual → más lento

· En pruebas típicas:

o sum(range) ≈ menos de 1 s.

o for tradicional ≈ alrededor de 1.6 s.

Conclusión gráfica:

🔥 sum gana en velocidad para datos grandes

📘 5. Big O — Visión rápida y visual

❓ Qué es

📉 Mide cómo crece el costo al aumentar los datos

🎯 Evalúa el peor caso

📏 Compara eficiencia entre algoritmos

🧩 Conceptos esenciales

· Complejidad = relación datos → recursos.

· Peor escenario = límite superior del costo.

· Comparación relativa = saber qué escala mejor.

Imagen mental →

Pequeño ahora ≠ Pequeño después

Big O te dice qué pasará cuando los datos exploten

Calidad de Código: Automatización y Validación

Python That Lasts in Production

Configuración inicial del proyecto Platy News con Python

Ruff: Formatea automáticamente código Python con facilidad

Fixing Real Type Errors With MyPy

Ruff Linter: Catch Python Bugs Before Runtime

Configuración de pre-commit con Ruff y MyPy para validar código

Ejecución paralela de pruebas unitarias con pytest y coverage

Configuración de GitHub Actions para CI/CD con Python

Configuración de logging y Sentry para monitoreo en producción

Rendimiento medición de velocidad y memoria

Medición de rendimiento de código con Timeit en Python

Análisis de rendimiento en Python con cProfile y Snakeviz

Programación concurrente con asyncio

Programación asíncrona en Python con AsyncIO para operaciones I/O

Sintaxis async y await en Python para concurrencia eficiente

How asyncio's Event Loop Schedules Tasks

Migración de Request síncrono a HTTPX asíncrono en Python

Distribución y empaquetamiento

Automate Dev Tasks with Make Targets

Publicación de paquetes Python con UV y TestPyPI

Medición de rendimiento de código con Timeit en Python

Progreso del curso

Calidad de Código: Automatización y Validación

Rendimiento medición de velocidad y memoria

Programación concurrente con asyncio

Distribución y empaquetamiento

Recursos

Recursos