Python Academy · Aula

Closures e variáveis livres

Capture estado em funções internas

Closures e variáveis livres é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Funções aninhadas

O Python permite definir uma função dentro de outra função. A função interna é criada novamente cada vez que a externa é executada.

def outer():
    def inner():
        return 'from inner'
    return inner()
print(outer())

A função interna vê as variáveis externas

Uma função interna pode ler variáveis definidas na função envolvente. Elas são chamadas de variáveis livres porque não são locais à função interna.

def outer():
    message = 'hello'
    def inner():
        return message
    return inner()
print(outer())

O que é um fechamento?

Um fechamento ocorre quando uma função interna é retornada e continua lembrando-se das variáveis livres do seu escopo envolvente, mesmo depois que esse escopo termina.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
g = make_greeter('Ada')
print(g())

O estado capturado permanece

A função externa já foi retornada, mas o fechamento ainda mantém name. O valor continua existindo dentro da função retornada.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
a = make_greeter('Ada')
b = make_greeter('Bob')
print(a())
print(b())

Uma fábrica de multiplicadores

Os fechamentos são especialmente úteis como fábricas que produzem funções personalizadas. Aqui, cada função retornada multiplica por um fator capturado.

def multiplier(factor):
    def multiply(n):
        return n * factor
    return multiply
double = multiplier(2)
triple = multiplier(3)
print(double(10))
print(triple(10))

Cada fechamento é independente

Cada chamada à fábrica cria um fechamento separado, com seu próprio valor capturado. Eles não interferem uns nos outros.

def adder(amount):
    def add(n):
        return n + amount
    return add
add5 = adder(5)
add100 = adder(100)
print(add5(1), add100(1))

Inspecionando valores capturados

Os nomes capturados são listados em __code__.co_freevars, e seus valores ficam armazenados nas células de __closure__.

def make(x):
    def f():
        return x
    return f
fn = make(42)
print(fn.__code__.co_freevars)
print(fn.__closure__[0].cell_contents)

Fechamentos capturam variáveis, não valores

Um fechamento captura a própria variável, portanto vê o valor final dela. Isso é importante quando a variável muda depois que o fechamento é criado.

def build():
    x = 1
    def show():
        return x
    x = 99
    return show
print(build()())

A armadilha do vínculo tardio em laços

Uma armadilha clássica: os fechamentos criados em um laço compartilham a mesma variável do laço, por isso capturam o último valor dela.

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])

Corrigindo o vínculo tardio

Associe o valor atual a um argumento padrão para que cada fechamento capture sua própria cópia no momento da definição.

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)
print([f() for f in funcs])

Fechamentos como objetos leves

Um fechamento reúne dados e comportamento, de modo muito semelhante a um pequeno objeto — geralmente mais simples que uma classe completa para casos básicos.

def counter_start(start):
    def value():
        return start
    return value
c = counter_start(10)
print(c())

Verificação rápida

O que é um fechamento no Python?

Recapitulação: fechamentos e variáveis livres

Ideias principais:

As funções internas podem ler variáveis do escopo envolvente (variáveis livres).
Um fechamento é uma função interna retornada que se lembra dessas variáveis.
Cada chamada à fábrica cria um fechamento independente.
Os fechamentos capturam variáveis, não valores, o que causa a armadilha do vínculo tardio em laços — corrija-a com um argumento padrão.

def power_of(exp):
    return lambda base: base ** exp
square = power_of(2)
print(square(9))

Perguntas Frequentes

A aula “Closures e variáveis livres” é grátis?

Sim — o texto completo de “Closures e variáveis livres” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Closures e variáveis livres”?

Capture estado em funções internas Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Closures e variáveis livres”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy