Memoização com lru_cache e geradores para memória

Não repita trabalho: lru_cache

Às vezes a otimização não é fazer o trabalho mais rápido, e sim não refazer o mesmo trabalho. Se uma função é chamada muitas vezes com as mesmas entradas e sempre devolve o mesmo resultado, guardar esse resultado e reutilizá-lo economiza tudo. Essa técnica é a memoização, e o functools.lru_cache a entrega pronta: você decora a função e o Python passa a lembrar os resultados. Na segunda chamada com a mesma entrada, ele devolve o valor guardado em vez de recalcular.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(35))          # instantaneo com cache
print(fib.cache_info())  # mostra hits e misses do cache

Sem cache, fib(35) recalcula os mesmos valores milhões de vezes; com lru_cache, cada um é feito uma vez.

O ganho no exemplo da sequência de Fibonacci é dramático porque a versão sem cache recalcula os mesmos valores um número absurdo de vezes. Com o lru_cache, cada valor é calculado uma vez e reaproveitado, transformando um cálculo lentíssimo em instantâneo. O parâmetro maxsize controla quantos resultados o cache guarda; com None, ele guarda todos. E o método cache_info revela quantas vezes o cache foi aproveitado, um bom diagnóstico de se ele está valendo a pena.

Geradores: processar muito sem gastar memória

Performance não é só tempo; memória também conta. Quando você carrega um arquivo gigante inteiro numa lista, ou monta uma lista com milhões de itens só para percorrê-la uma vez, o programa pode engasgar ou estourar a memória. Os geradores resolvem isso com avaliação preguiçosa: eles produzem um valor por vez, sob demanda, sem nunca guardar a sequência inteira. Trocar uma list comprehension entre colchetes por uma expressão geradora entre parênteses já é o suficiente em muitos casos.

# Lista: cria um milhao de itens na memoria de uma vez
soma = sum([n * n for n in range(1_000_000)])

# Gerador: produz um item por vez, memoria quase constante
soma = sum(n * n for n in range(1_000_000))

# Ler um arquivo enorme linha a linha, sem carregar tudo
def contar_erros(caminho):
    total = 0
    with open(caminho, encoding="utf-8") as f:
        for linha in f:            # o arquivo e iterado preguicosamente
            if "ERRO" in linha:
                total += 1
    return total

A versão com gerador (parênteses) não materializa a lista; iterar o arquivo linha a linha faz o mesmo.

Armadilhas comuns de performance

Alguns padrões custam caro sem parecer. O mais famoso é concatenar strings com o operador mais dentro de um laço: como strings são imutáveis, cada mais cria uma string nova e copia todo o conteúdo anterior, o que vira O(n ao quadrado). A solução é acumular os pedaços numa lista e juntar uma vez só com str.join. Outra armadilha é verificar pertencimento numa lista dentro de um laço, quando um set resolveria em O(1). E há o clássico de recriar, dentro de um laço, algo que poderia ser calculado uma vez fora dele.

# Lenta: concatena string dentro do laco (O(n ao quadrado))
def juntar_ruim(itens):
    s = ""
    for x in itens:
        s += str(x) + ", "
    return s

# Rapida: acumula e junta uma vez (O(n))
def juntar_bom(itens):
    return ", ".join(str(x) for x in itens)

A concatenação em laço copia tudo a cada volta; str.join monta a string final de uma vez.

Perceba que nenhuma dessas correções é um truque obscuro: todas são também o jeito mais pythônico e legível de escrever. Esse é o resumo do módulo. Medir aponta onde agir; a estrutura de dados certa muda a ordem de grandeza; o cache evita repetir trabalho; os geradores poupam memória; e evitar as armadilhas clássicas já entrega código rápido e limpo ao mesmo tempo. Performance, no avançado, raramente é sobre esperteza; é sobre medir, escolher bem e conhecer as ferramentas que a linguagem já oferece.