Closures

A função que lembra

Na aula 2 você viu uma função devolver outra função. Agora vamos olhar o que torna esse padrão poderoso de verdade. Quando a função interna usa uma variável que veio da função externa, acontece algo curioso: mesmo depois de a função externa terminar e sair da memória, a função interna continua lembrando daquele valor. Essa combinação de uma função interna com o ambiente que ela guardou tem um nome: closure. A palavra vem da ideia de que a função interna fecha ao redor das variáveis que usou.

Parece mágica, mas é uma regra clara. Quando o Python cria a função interna, ele anota de quais variáveis externas ela precisa e mantém essas variáveis vivas enquanto a função interna existir. Repare no exemplo: criar_multiplicador termina e devolve a função de dentro, mas o valor de fator não se perde. A função devolvida ainda o conhece. É por isso que dobro sabe multiplicar por 2 e triplo sabe multiplicar por 3, cada um com o seu próprio fator lembrado.

def criar_multiplicador(fator):
    def multiplicar(numero):
        return numero * fator   # usa "fator" da funcao externa
    return multiplicar

dobro = criar_multiplicador(2)
triplo = criar_multiplicador(3)

print(dobro(10))   # 20  (lembra fator = 2)
print(triplo(10))  # 30  (lembra fator = 3)
print(dobro(7))    # 14

Cada função devolvida guarda o seu próprio fator: isso é um closure.

Fábricas de funções independentes

Uma função como criar_multiplicador é uma fábrica de funções. Você a chama com um argumento e recebe uma função nova, ajustada para aquele argumento. Cada chamada produz um closure independente, com o seu próprio valor guardado. dobro e triplo não compartilham nada: são duas funções distintas, cada uma com o seu fator preso. Isso permite gerar variações sob medida sem repetir código. Em vez de escrever uma função para dobrar, outra para triplicar e outra para multiplicar por dez, você escreve a fábrica uma vez e pede as versões que precisar.

def criar_saudacao(saudacao):
    def cumprimentar(nome):
        return f"{saudacao}, {nome}!"
    return cumprimentar

# Uma fabrica, varias funcoes independentes
bom_dia = criar_saudacao("Bom dia")
boa_noite = criar_saudacao("Boa noite")

print(bom_dia("Ana"))      # Bom dia, Ana!
print(boa_noite("Bruno"))  # Boa noite, Bruno!

# Prova de independencia: cada uma lembra a sua saudacao
funcoes = [criar_saudacao(s) for s in ["Oi", "Alô"]]
print(funcoes[0]("Carla"))  # Oi, Carla!
print(funcoes[1]("Davi"))   # Alô, Davi!

Cada função criada pela fábrica lembra a sua própria saudação, sem interferência.

Fixando: a função que fecha ao redor

Feche a aula com a imagem que dá nome ao conceito: a função interna fecha ao redor das variáveis que usou, levando-as consigo para onde for chamada. Isso permite escrever fábricas de funções, gerando versões especializadas a partir de um único molde, cada uma com o seu valor lembrado. Você não precisa dominar todos os usos agora. O importante é reconhecer o padrão, porque ele volta com força no módulo de decoradores, onde os closures deixam de ser curiosidade e viram ferramenta do dia a dia.