1) Profiling: entenda onde o tempo está sendo gasto

Antes de qualquer otimização, mensure com dados reais. Profiling ajuda a priorizar mudanças que geram impacto. Diferencio CPU-bound de IO-bound e interpreto métricas de tempo de CPU total (cumtime) vs tempo de execução da função (tottime).

• Use profiling em cenários reais de uso, com carga representativa.
• Ferramentas recomendadas: cProfile (inclusa no stdlib), Py-Spy para produção, yappi para perfis de múltiplas threads.
• Examine resultados com cuidado: funções que aparecem repetidamente no topo do cumtime costumam ser gargalos promissores.

Comandos básicos (exemplos):

# Profilação básica
python -m cProfile -o perfil.prof meu_script.py
python -m pstats perfil.prof --sort cumtime

# Perfil em ambiente de produção (com Py-Spy)
py-spy top --pid $(pidof python)

2) Otimizações de código Python: padrões que entregam ganhos reais

Alguns padrões simples, bem aplicados, entregam ganhos significativos sem adotar técnicas avançadas. Foque em reduzir overheads de chamadas, evitar criações desnecessárias de objetos e usar APIs nativas de alto desempenho.

• Prefira operações com APIs nativas do Python (sum, min, max, any, all) e use geradores quando possível para evitar memória extra.
• Acesso a atributos deve ser local, reduzindo lookups repetidos; importe funções diretamente quando fizer sentido.
• Concentração de criação de strings: concatenação com += é custosa; use join para compor grandes blocos de texto.
• Mantém caches com lru_cache para resultados caros que repetem com o mesmo conjunto de entradas.

Exemplo prático: substitua concatenação por join

// Before
def join_strings(parts):
    s = ""
    for p in parts:
        s += p
    return s

// After
def join_strings(parts):
    return "".join(parts)

3) Estruturas de dados, bibliotecas e paralelismo

Quando o volume de dados cresce, vale escolher estruturas e operações que reduzem o tempo de execução. Em tarefas numéricas, valem-se numpy/pandas para operações vetorizadas. Para tarefas CPU-bound, avalie o uso de paralelismo com multiprocessing ou concurrent.futures para contornar o GIL.

• Vectorização: substitua loops puros por operações de array/bjeto vetorizadas quando possível.
• Memória: prefira iteradores, generators e pipeline de processamento para não manter dados desnecessários na memória.
• Memoização: use functools.lru_cache para evitar recomputações caras com entradas repetidas.
• Garbage collector: evite retenções desnecessárias de referências; avalie ciclos de GC para cenários de alto throughput.

4) Ambiente, deployment e tuning

O ambiente de execução influencia diretamente o desempenho observado. Escolha o interpretador adequado, ajuste configurações de GC, e planeje o pipeline de deployment para manter o desempenho estável sob carga.

• CPython vs PyPy: PyPy costuma entregar ganhos em loops puros, enquanto CPython pode ter melhor compatibilidade com bibliotecas nativas.
• Garbage collector: ajuste o limiar do GC conforme o perfil da aplicação; desabilitar o GC não é recomendado sem avaliação cuidadosa.
• Paralelismo: para tarefas CPU-bound, use multiprocessing ou processos; para IO-bound, explore asyncio e agentes assíncronos.
• Ambiente de produção: containers leves, servidores WSGI otimizados e buffers adequados ajudam na estabilidade de throughput.

Exemplo adicional: uso de iteradores para streaming de dados grandes

Quando processamos grandes volumes de dados, consumir tudo na memória é inviável. Um approach é usar geradores para streaming de dados, mantendo o footprint baixo.

def ler_linhas(grande_arquivo):
    with open(grande_arquivo, 'r', encoding='utf-8') as f:
        for linha in f:
            yield linha.rstrip('\\n')

def processar(linhas):
    for linha in linhas:
        # processamento simples
        yield len(linha)

def pipeline(arquivo):
    for tamanho in processar(ler_linhas(arquivo)):
        yield tamanho

# uso
for t in pipeline('dados/grande_arquivo.txt'):
    pass  # substitua pelo seu processamento