Como você faz profiling e otimização de performance em Python?

Question

Accepted Answer

Otimizar Python começa com **profiling para encontrar o verdadeiro gargalo** — nunca adivinhe. A natureza interpretada e dinâmica do Python o torna mais lento que linguagens compiladas, então a otimização se concentra em melhores algoritmos, aproveitamento de bibliotecas com suporte em C e redução da sobrecarga do interpretador em hot paths.

## Profile primeiro

```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
```

Profiling revela *onde* o tempo realmente é gasto, para que você otimize os 20% do código que importam — não palpites aleatórios.

## O maior ganho: melhores algoritmos e estruturas de dados

```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
```

Melhorias algorítmicas (estrutura de dados correta, evitar padrões O(n²)) geralmente superam micro-otimizações — uma busca em set vs varredura em lista pode ser ordens de magnitude mais rápida.

## Use bibliotecas com suporte em C para trabalho 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 trabalho numérico/dados, bibliotecas como **NumPy/pandas** executam os loops pesados em C (liberando a GIL), superando vastamente loops em pure-Python.

## Outras técnicas de otimização

```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
```

## Exemplo de caching

```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
```

## Não otimize prematuramente

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

## Por que isso importa

A lentidão relativa do Python torna a consciência de performance valiosa, mas a otimização efetiva é **disciplinada**: faça profiling primeiro (cProfile/line_profiler) para encontrar o verdadeiro gargalo, depois aplique a correção de maior impacto — geralmente um melhor algoritmo/estrutura de dados (O(n) → O(1) lookups), bibliotecas com suporte em C (NumPy/pandas) para trabalho numérico, caching para computação repetida e built-ins/generators para eficiência.

Conhecer essas técnicas — e o princípio de medir antes de otimizar em vez de adivinhar ou otimizar prematuramente em nível micro — é o que permite tornar o Python rápido o suficiente onde importa, mantendo o código claro em qualquer outro lugar.