¿Cómo perfilas y optimizas el rendimiento de Python?

Question

Accepted Answer

Optimizar Python empieza por **perfilar para encontrar el cuello de botella real**, nunca adivinar. La naturaleza interpretada y dinámica de Python lo hace más lento que los lenguajes compilados, así que la optimización se centra en mejores algoritmos, aprovechar librerías respaldadas por C y reducir la sobrecarga del intérprete en las rutas críticas.

## Perfila primero

```python
import cProfile
cProfile.run("my_function()")   # shows time spent per function call

# line-level profiling (third-party)
# pip install line_profiler → @profile decorator → kernprof -l -v script.py
```

```bash
python -m cProfile -s cumtime script.py   # sort by cumulative time → find hotspots
```

El perfilado revela *dónde* va realmente el tiempo, para que optimices el 20 % del código que importa, no suposiciones al azar.

## La mayor ganancia: mejores algoritmos y estructuras de datos

```python
# ❌ O(n) membership test in a list — slow for large data
if item in my_list: ...          # scans every element

# ✅ O(1) membership test in a set/dict
if item in my_set: ...           # hash lookup — dramatically faster at scale
```

Las mejoras algorítmicas (la estructura de datos adecuada, evitar patrones O(n²)) suelen eclipsar a las microoptimizaciones: una búsqueda en un set frente a un recorrido de una lista puede ser órdenes de magnitud más rápida.

## Usa librerías respaldadas por C para el trabajo numérico pesado

```python
# ❌ pure-Python loop over millions of numbers — slow (interpreter overhead per element)
result = [x * 2 for x in big_list]

# ✅ NumPy does it in optimized C, vectorized — far faster
import numpy as np
result = np.array(big_list) * 2
```

Para el trabajo numérico o de datos, librerías como **NumPy/pandas** ejecutan los bucles pesados en C (liberando el GIL), superando ampliamente a los bucles en Python puro.

## Otras técnicas de optimización

```text
✓ Caching/memoization: @functools.lru_cache for repeated expensive calls
✓ Use built-ins (sum, map, sorted) — implemented in C, faster than manual loops
✓ Use generators for large data (avoid building huge lists in memory)
✓ Use local variables in hot loops (local lookup is faster than global/attribute)
✓ Use __slots__ to reduce per-object memory for many instances
✓ For CPU parallelism: multiprocessing (bypass the GIL)
✓ Last resort: rewrite hotspots in C / Cython / Rust (PyO3), or try PyPy
```

## Ejemplo de caché

```python
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)   # memoized → exponential becomes linear
```

## No optimices prematuramente

```text
"Premature optimization is the root of all evil." Write clear code first,
profile to find real bottlenecks, then optimize those specifically.
```

## Por qué es importante

La relativa lentitud de Python hace valiosa la conciencia sobre el rendimiento, pero la optimización efectiva es **disciplinada**: perfila primero (cProfile/line_profiler) para encontrar el verdadero cuello de botella, y luego aplica la solución de mayor impacto, normalmente un mejor algoritmo/estructura de datos (búsquedas O(n) → O(1)), librerías respaldadas por C (NumPy/pandas) para el trabajo numérico, caché para el cómputo repetido y elementos integrados/generadores para la eficiencia.

Conocer estas técnicas —y el principio de medir antes de optimizar en lugar de adivinar o microoptimizar prematuramente— es lo que te permite hacer Python lo bastante rápido donde importa mientras mantienes el código claro en todo lo demás.