(Embora ilustrado em Python, creio que conhecer Python não seja totalmente necessário para entender o post :) )
Você conhece o conceito de closures (“fecho”, mas acho que ninguém usa o termo em português…)? Basicamente, é quando você pode definir uma função em tempo de execução e esta função faz referência a variáveis de um escopo externo a ela. Por exemplo:
def make_number_printer(n): def number_printer(): print n return number_printer printer = make_number_printer(5) printer()
A função make_number_printer recebe um número e retorna uma função que, quando chamada, imprime esse mesmo número. Não é a função mais útil do universo, mas ilustra bem o conceito de closure. No caso, a função number_printer é uma closure, pois referencia a variável n que está num escopo externo (o da função make_number_printer).
Porém minha intenção aqui não é tanto explicar o que são closures, mas sim ilustrar uma característica que pode acabar confundindo (já perdi um bom tempo caçando um bug causado por isso). O que esse código imprime?
printer_lst = [] for i in xrange(10): def number_printer(): print i printer_lst.append(number_printer) for printer in printer_lst: printer()
Ele executa um loop de 0 a 9, em cada iteração criando uma função number_printer e colocando-a numa lista, e em seguida percorre essa lista chamando todas as funções. Era de se esperar que ele imprimisse os números de 0 a 9, certo?
Errado! Ele imprime o número 9 dez vezes.
O problema é que na maioria das vezes, intuitivamente pensa-se que as closures funcionam “fixando” o valor das variáveis externas que elas referenciam para usá-las num momento posterior. Mas na verdades elas guardam uma referência àquela variável, e se ela mudar de valor, a closure usará o valor alterado. Como a nossa variável i vale 9 no final da criação das closures, esse é o valor que todas vão imprimir. Isso vale mesmo se a variável i deixar de existir após a criação das closures (por exemplo, se o primeiro for estivesse dentro de uma função).
Como resolver isso? Você pode mover a criação da closure para uma outra função, desta forma:
def make_number_printer(n): def number_printer(): print n return number_printer printer_lst = [] for i in xrange(10): printer_lst.append(make_number_printer(i)) for printer in printer_lst: printer()
Assim a closure irá referenciar a variável n, que possui instâncias diferentes para cada closure diferente criada. Outra alternativa é utilizar um “recurso” polêmico do Python, que é o fato de que os valores de parâmetros com valores padrão são avaliados quando a função é definida, e não quando ela é chamada:
printer_lst = [] for i in xrange(10): def number_printer(x=i): print x printer_lst.append(number_printer) for printer in printer_lst: printer()
Ao executar def number_printer(x=i):, o valor de i é avaliado e salvo permanentemente na definição da função; assim, cada vez que a função é definida (a closure é criada) o valor atual de i é “congelado”.
Se alguém se estiver perguntando, “mas eu nunca vou acabar me deparando com isso”, este é um exemplo um pouco mais próximo da realidade (na verdade me bati com ele quando programava um jogo em Flash, que usa ActionScript). Fundamentalmente é o mesmo código acima e apresenta o mesmo problema:
class Button: #Esta é uma classe para simular um botão, suponha #que é parte de uma biblioteca de GUI e por alguma #razão você não pode herdar dela def __init__(self): self.listener = None def set_click_listener(self, fn): self.listener = fn def on_click(self): self.listener() #Cria 10 botões... buttons = [Button() for i in xrange(10)] #E suponha que eles são adicionados na interface #Seta os listeners para o evento de clique. #O número de botões pode mudar no futuro #e todos têm o mesmo código, a única diferença #sendo o índice do botão. Então é melhor fazer isso #dentro de um loop. for i in xrange(10): def on_click(): #Imagine que o código aqui seja mais útil print i buttons[i].set_click_listener(on_click) #Simula um clique em cada botão for j in xrange(10): buttons[j].on_click()