Medir y perfilar el rendimiento del código
Medir y perfilar el rendimiento del código
La notación big O predice cómo escala el código. Para obtener información sobre la rapidez con la que se ejecuta realmente el código, hay que medirlo. Cuando un programa completo es lento, se perfila para encontrar la función que causa el retraso. En esta unidad se enseñan ambas técnicas.
Medir con timeit
El módulo integrado timeit de Python mide cuánto tiempo tarda el código en ejecutarse. El código siguiente compara dos maneras de agregar los números de 0 a 999:
import timeit
def sum_with_loop():
total = 0
for i in range(1000):
total += i
return total
def sum_with_builtin():
return sum(range(1000))
time1 = timeit.timeit(sum_with_loop, number=10000)
time2 = timeit.timeit(sum_with_builtin, number=10000)
print(f"Loop version: {time1:.4f} seconds")
print(f"Built-in version: {time2:.4f} seconds")
print(f"Built-in is {time1 / time2:.1f}x faster")
Loop version: 0.2306 seconds
Built-in version: 0.0888 seconds
Built-in is 2.6x faster
Los tiempos difieren, pero la versión integrada es más rápida.
El number=10000 argumento ejecuta la función 10 000 veces y devuelve el tiempo total. Ejecutar el código muchas veces suaviza pequeñas variaciones en la velocidad del equipo.
Ambas versiones son O(n), por lo que Big O no explica la diferencia. La función integrada sum es más rápida porque Python la ejecuta en código C optimizado, mientras que el bucle se ejecuta como código Python. Big O describe cómo crece el trabajo y la medición muestra cuánto cuesta cada paso.
Medir en distintos tamaños de datos
Para ver el patrón Big O, mide el tiempo de ejecución de la misma función con más datos. La timeit función necesita una función que no toma argumentos, por lo que encapsula una llamada que toma argumentos en un lambda contenedor, como hace el ejemplo siguiente. La función cuenta valores duplicados comparando cada par de elementos, por lo que es O(n²):
import timeit
def count_duplicates(numbers):
count = 0
for i in range(len(numbers)):
for j in range(i + 1, len(numbers)):
if numbers[i] == numbers[j]:
count += 1
return count
for size in [500, 1000, 2000]:
data = list(range(size))
time_taken = timeit.timeit(lambda: count_duplicates(data), number=3)
print(f"{size:5d} items: {time_taken:.3f}s")
500 items: 0.009s
1000 items: 0.040s
2000 items: 0.156s
Cada vez que los datos se duplican, el tiempo se cuadruplica aproximadamente. Esto coincide con el patrón O(n²) de la unidad anterior.
Decidir qué medir
No mida todas las funciones. Mida cuando:
- Una función se ejecuta con frecuencia.
- Una función controla grandes cantidades de datos.
- Tiene dos enfoques y no puede decidir entre ellos.
- Los usuarios informan de que algo es demasiado lento.
Una función que se ejecuta una vez al inicio rara vez necesita medirse. Una función que se ejecuta millones de veces sí.
Buscar el cuello de botella con cProfile
Medir el tiempo de ejecución de una función muestra la rapidez con la que se ejecuta esa función. Cuando un programa completo es lento, debe saber en qué función centrarse. Un cuello de botella es la parte de un programa que limita su velocidad global, y un generador de perfiles lo encuentra informando de dónde gasta el programa su tiempo.
El módulo integrado cProfile de Python informa cuántas veces se llamó a cada función y cuánto tiempo tardó cada una. El siguiente programa tiene tres pasos y uno de ellos es lento:
import cProfile
def load_numbers(count):
return list(range(count))
def find_pairs(numbers, target):
pairs = []
for i in range(len(numbers)):
for j in range(len(numbers)):
if numbers[i] + numbers[j] == target:
pairs.append((numbers[i], numbers[j]))
return pairs
def summarize(pairs):
return len(pairs)
def run_report():
numbers = load_numbers(2000)
pairs = find_pairs(numbers, 100)
return summarize(pairs)
cProfile.run("run_report()", sort="tottime")
El argumento sort="tottime" enumera en primer lugar las funciones que más tiempo consumieron. El resultado tiene este aspecto:
2110 function calls in 0.172 seconds
Ordered by: internal time
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.172 0.172 0.172 0.172 profile_example.py:8(find_pairs)
2002 0.000 0.000 0.000 0.000 {built-in method builtins.len}
1 0.000 0.000 0.172 0.172 profile_example.py:21(run_report)
1 0.000 0.000 0.000 0.000 profile_example.py:4(load_numbers)
1 0.000 0.000 0.000 0.000 profile_example.py:17(summarize)
Sus horarios y algunas líneas difieren. Estas columnas importan más:
| Columna | Meaning |
|---|---|
ncalls |
Cuántas veces se llamó a la función. |
tottime |
Tiempo invertido dentro de la propia función, sin contar las funciones a las que llama. |
cumtime |
Tiempo empleado en la función y en todo lo que llama. |
La función find_pairs tiene casi todo el tottime, por lo que es el cuello de botella. Los bucles anidados lo convierten en O(n²). Optimizar load_numbers o summarize no ayudaría, porque apenas requieren tiempo.
Sigue el flujo de trabajo de optimización
Siga los mismos pasos cada vez:
- Mida todo el programa. Anota lo lento que es.
- Realice un perfilado para encontrar el cuello de botella. Identifique la función con más tiempo.
- Mida esa función. Compruebe cuánto tiempo podría ahorrar.
- Optimice si vale la pena. Asegúrese de que el beneficio justifica la complejidad agregada.
- Vuelve a medir. Confirme que el cambio ha hecho el programa más rápido y que sigue devolviendo el mismo resultado.
Las mayores ganancias suelen provenir de un algoritmo mejor, como reemplazar un enfoque de O(n²) por un enfoque de O(n). Cambios pequeños, como quitar una variable, rara vez importan.
Evitar la optimización prematura
El científico informático Donald Knuth escribió que "la optimización prematura es la raíz de todo mal". En la práctica, esto significa:
- No optimice el código que ya es lo suficientemente rápido.
- No adivines dónde está el cuello de botella. Mídelo.
- No haga que el código sea más difícil de leer para ahorrar un milisegundo.
El perfilado le permite dedicar sus esfuerzos donde más impacto tengan.