Funções puras e imutabilidade

O que torna uma função pura

A programação funcional gira em torno de uma ideia simples: tratar funções como valores e preferir funções puras. Uma função é pura quando seu resultado depende apenas dos argumentos que recebe e ela não muda nada fora de si. Chame-a mil vezes com os mesmos dados e o resultado será sempre o mesmo, sem surpresas. Ela não mexe em variáveis globais, não escreve em arquivos, não altera a lista que recebeu. Toda a sua ação é devolver um valor.

# Pura: so depende dos argumentos, nao altera nada fora.
def com_desconto(preco: float, taxa: float) -> float:
    return preco * (1 - taxa)

print(com_desconto(100.0, 0.1))  # 90.0
print(com_desconto(100.0, 0.1))  # 90.0 sempre

# Impura: altera uma lista recebida (efeito colateral).
def adicionar_item(carrinho: list[str], item: str) -> None:
    carrinho.append(item)  # muda o argumento por fora

com_desconto é pura; adicionar_item causa efeito colateral ao mudar a lista recebida.

A função com_desconto é pura: dois preços iguais e duas taxas iguais dão sempre o mesmo resultado, e nada mais no programa muda. Já adicionar_item é impura, porque altera a lista que recebeu, um efeito colateral. Isso não é proibido, e às vezes é exatamente o que você quer, mas funções impuras são mais difíceis de entender e testar, porque o resultado passa a depender de coisas fora dos argumentos. A recomendação prática é manter pura a maior parte da lógica e isolar os efeitos colaterais em poucos pontos.

Por que a pureza facilita a vida

Funções puras trazem vantagens concretas. Testar fica trivial: você passa argumentos e confere o retorno, sem precisar preparar um estado global nem limpar nada depois. Entender fica mais fácil: para saber o que a função faz, basta olhar para ela, sem rastrear o que ela altera pelo programa. E reaproveitar fica seguro: como ela não depende de contexto externo, você a move para outro lugar sem medo. Muito da dor de manter software vem de efeitos colaterais espalhados; concentrá-los é um alívio.

Imutabilidade na prática

A imutabilidade anda de mãos dadas com a pureza. Em vez de alterar uma estrutura no lugar, você gera uma nova a partir dela. Ordenar uma lista com sorted devolve uma lista nova, sem tocar na original; usar o método sort altera a lista existente. Somar um item a uma tupla cria outra tupla, pois tuplas não mudam. Trabalhar assim evita o bug em que uma parte do código altera um dado que outra parte ainda usava, esperando o valor antigo. O dado passa a ser previsível.

numeros = [3, 1, 2]

# Imutavel: cria uma lista nova, preserva a original.
ordenados = sorted(numeros)
print(ordenados)  # [1, 2, 3]
print(numeros)    # [3, 1, 2]  intacta

# Mutavel: altera a lista no lugar.
numeros.sort()
print(numeros)    # [1, 2, 3]  mudou

sorted devolve uma lista nova; sort altera a original. A imutabilidade preserva o dado.

Nenhum estilo é o certo em absoluto; Python é uma linguagem multiparadigma e mistura os dois com naturalidade. O ponto é ter a escolha consciente. Quando você prefere transformar em vez de alterar, e mantém a lógica em funções puras, o código fica mais fácil de raciocinar, testar e paralelizar. As próximas aulas trazem ferramentas que apoiam esse estilo: o functools, com reduce, partial e cache, e o itertools, com geradores e combinadores prontos.