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.