Controlar a vinculação tardia em closures

Uma função interna pode ser criada em um laço e armazenada em uma lista sem que seu corpo seja executado naquele instante. A execução só acontece quando você chama cada função, por exemplo com funcao().

Em uma closure, o nome vindo da função externa é consultado quando a função interna roda. Portanto, não suponha que a criação automática guardou o valor que o laço tinha naquela iteração.

Leia primeiro sem executar: em que momento numero é consultado?

Durante o laço, são criadas e adicionadas à lista três funções internas. O corpo de cada lambda ainda não foi executado.

Depois da última iteração, numero vale 2. A função externa retorna a lista; só então a compreensão chama cada consulta(). Em cada chamada, a consulta a numero encontra o valor vigente: 2.

A imagem separa o momento de montar a lista do momento de executar as funções.

Dentro de uma chamada de função, o for atualiza o mesmo vínculo da variável do laço a cada iteração. Ele não cria um novo escopo de função para cada volta.

Por isso, funções internas diferentes criadas nesse laço podem apontar para o mesmo vínculo de numero. Quando forem chamadas depois, todas consultarão o valor que esse vínculo tiver naquele momento.

Cada cartão representa uma função distinta. As setas convergem porque todas acessam a mesma variável do laço.

As duas listas são criadas em uma única chamada de montar().

lambda e def criam objetos função distintos, mas ambos consultam o mesmo numero do ambiente envolvente. Assim, substituir lambda por def não resolve uma captura compartilhada.

Aqui, cada função é chamada imediatamente e depois do término do laço.

Durante cada iteração, o vínculo compartilhado ainda tem o valor corrente, então a chamada imediata observa 0, depois 1, depois 2. Ao final, o laço deixou esse mesmo vínculo com 2; as chamadas posteriores consultam todas esse valor.

Em uma função criada no laço, escreva um parâmetro padrão com o valor corrente: valor=i. Esse valor é associado ao objeto função naquela iteração. No corpo, use o parâmetro local valor, e não a variável livre i.

À esquerda, todas as funções consultam o mesmo vínculo i. À direita, cada função possui seu próprio parâmetro padrão valor.

Nas duas listas, as chamadas ocorrem depois do término do laço.

Em consultar(valor=i) e lambda valor=i: valor, o corpo retorna valor, que é local à chamada. Como nenhum argumento foi fornecido, Python usa o padrão armazenado em cada função.

O valor fixado é o padrão da chamada, não uma constante inacessível.

Quando o laço chama uma fábrica, o valor corrente é recebido como argumento. Cada chamada da fábrica cria seu próprio vínculo para esse parâmetro; a função retornada consulta esse vínculo, não a variável reutilizada pelo laço.

Cada seta representa uma chamada distinta da fábrica.

A função retornada não recebe argumentos: sua interface permanece sem parâmetros.

criar_consulta(numero) é executada em cada iteração. Assim, as três funções consultar foram criadas em chamadas externas diferentes. Em contraste, definir várias funções diretamente no mesmo corpo externo faria todas consultarem o mesmo vínculo do laço.

Ao escrever lambda registro=registro: registro, o parâmetro padrão guarda a referência atual ao objeto. Ele não cria uma nova lista nem um novo dicionário.

Por isso, se esse mesmo objeto for alterado depois, a função verá a alteração.

Execute e observe os dois resultados.

Uma fábrica cria um vínculo próprio em cada chamada, mas os argumentos recebidos ainda podem ser referências ao mesmo objeto. Portanto, vínculos independentes não implicam objetos independentes.

As duas chamadas da fábrica recebem a mesma lista.

A vinculação tardia não é necessariamente um defeito. Mantenha o vínculo compartilhado quando todas as funções devem consultar o valor mais atual da variável externa no momento da chamada.

Fixe a referência quando cada função deve manter a associação que recebeu ao ser criada. Se a exigência for que cada função tenha também um objeto mutável independente, fixar a referência não basta: será preciso criar uma cópia adequada do objeto.

Compare o que cada estratégia preserva.

Uma função de consulta deve ser criada para cada registro e chamada apenas depois que criar_consultas terminar. Cada consulta precisa conservar a referência ao registro correspondente à sua criação.

No código inicial, todas as lambdas consultam a mesma variável registro do laço quando são chamadas. Portanto, elas acabam retornando o último registro.

Compare as setas antes de alterar o código.

No seu computador, crie um arquivo chamado consultas.py, copie o script abaixo e execute python consultas.py.

Primeiro, rode sem alterar nada: o primeiro assert deve falhar. Em seguida, corrija somente a linha marcada com # CORRIJA AQUI, usando uma das estratégias estudadas. Execute de novo até que não haja saída nem erro — isso indica que todos os asserts passaram.

Script inicial com uma captura tardia intencional.

Os três primeiros asserts verificam identidades: cada consulta retorna exatamente o objeto da respectiva posição original.

Depois, a alteração de status é uma mutação no mesmo dicionário; por isso ela aparece na primeira consulta. Já a atribuição de um novo dicionário a registros[0] troca o objeto guardado na lista, mas não altera a referência que a closure já conservava.