Bagaimana cara kerja penutupan leksikal?

Sementara saya sedang menyelidiki masalah yang saya miliki dengan penutupan leksikal dalam kode Javascript, saya menemukan masalah ini dengan Python:

flist = []

for i in xrange(3):
    def func(x): return x * i
    flist.append(func)

for f in flist:
    print f(2)

Perhatikan bahwa contoh ini dengan sadar menghindari lambda. Mencetak "4 4 4", yang mengejutkan. Saya harapkan "0 2 4".

Kode Perl yang setara ini melakukannya dengan benar:

my @flist = ();

foreach my $i (0 .. 2)
{
    push(@flist, sub {$i * $_[0]});
}

foreach my $f (@flist)
{
    print $f->(2), "\n";
}

"0 2 4" dicetak.

Bisakah Anda jelaskan perbedaannya?

Memperbarui:

Masalahnya bukan dengan imenjadi global. Ini menampilkan perilaku yang sama:

flist = []

def outer():
    for i in xrange(3):
        def inner(x): return x * i
        flist.append(inner)

outer()
#~ print i   # commented because it causes an error

for f in flist:
    print f(2)

Seperti yang ditunjukkan oleh baris yang dikomentari, itidak diketahui pada saat itu. Namun, ia mencetak "4 4 4".

Python sebenarnya berperilaku seperti yang didefinisikan. Tiga fungsi terpisah dibuat, tetapi masing-masing memiliki penutupan lingkungan yang telah ditentukan - dalam hal ini, lingkungan global (atau lingkungan fungsi luar jika loop ditempatkan di dalam fungsi lain). Ini persis masalah, meskipun - dalam lingkungan ini, saya dimutasi , dan semua penutup mengacu pada i yang sama .

Berikut ini adalah solusi terbaik yang bisa saya buat - buat fungsi creater dan panggil itu . Ini akan memaksa lingkungan yang berbeda untuk setiap fungsi yang dibuat, dengan i berbeda di masing -masing fungsi .

flist = []

for i in xrange(3):
    def funcC(j):
        def func(x): return x * j
        return func
    flist.append(funcC(i))

for f in flist:
    print f(2)

Inilah yang terjadi ketika Anda mencampur efek samping dan pemrograman fungsional.

Fungsi-fungsi yang didefinisikan dalam loop tetap mengakses variabel yang sama isaat nilainya berubah. Pada akhir loop, semua fungsi menunjuk ke variabel yang sama, yang memegang nilai terakhir dalam loop: efeknya adalah apa yang dilaporkan dalam contoh.

Untuk mengevaluasi idan menggunakan nilainya, pola umum adalah menetapkannya sebagai parameter default: standar parameter dievaluasi ketika defpernyataan dieksekusi, dan dengan demikian nilai variabel loop dibekukan.

Berikut ini berfungsi seperti yang diharapkan:

flist = []

for i in xrange(3):
    def func(x, i=i): # the *value* of i is copied in func() environment
        return x * i
    flist.append(func)

for f in flist:
    print f(2)

Inilah cara Anda melakukannya menggunakan functoolsperpustakaan (yang saya tidak yakin tersedia pada saat pertanyaan diajukan).

from functools import partial

flist = []

def func(i, x): return x * i

for i in xrange(3):
    flist.append(partial(func, i))

for f in flist:
    print f(2)

Output 0 2 4, seperti yang diharapkan.

Lihat ini:

for f in flist:
    print f.func_closure


(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)

Ini berarti mereka semua menunjuk ke instance variabel i yang sama, yang akan memiliki nilai 2 setelah loop selesai.

Solusi yang mudah dibaca:

for i in xrange(3):
        def ffunc(i):
            def func(x): return x * i
            return func
        flist.append(ffunc(i))

Apa yang terjadi adalah bahwa variabel i ditangkap, dan fungsinya mengembalikan nilai yang terikat pada saat ia dipanggil. Dalam bahasa fungsional situasi seperti ini tidak pernah muncul, karena saya tidak akan pulih. Namun dengan python, dan juga seperti yang Anda lihat dengan lisp, ini tidak lagi benar.

Perbedaannya dengan contoh skema Anda adalah hubungannya dengan semantik loop do. Skema secara efektif membuat variabel i baru setiap kali melalui loop, daripada menggunakan kembali saya yang mengikat seperti dengan bahasa lain. Jika Anda menggunakan variabel berbeda yang dibuat di luar untuk loop dan mengubahnya, Anda akan melihat perilaku yang sama dalam skema. Coba ganti loop Anda dengan:

(let ((ii 1)) (
  (do ((i 1 (+ 1 i)))
      ((>= i 4))
    (set! flist 
      (cons (lambda (x) (* ii x)) flist))
    (set! ii i))
))

Lihatlah di sini untuk diskusi lebih lanjut tentang ini.

[Sunting] Mungkin cara yang lebih baik untuk menggambarkannya adalah dengan menganggap do loop sebagai makro yang melakukan langkah-langkah berikut:

1. Tentukan lambda mengambil parameter tunggal (i), dengan tubuh yang ditentukan oleh tubuh loop,
2. Panggilan langsung dari lambda itu dengan nilai i yang sesuai sebagai parameternya.

yaitu. setara dengan python di bawah ini:

flist = []

def loop_body(i):      # extract body of the for loop to function
    def func(x): return x*i
    flist.append(func)

map(loop_body, xrange(3))  # for i in xrange(3): body

I bukan lagi yang berasal dari lingkup induk tetapi variabel baru dalam cakupannya sendiri (mis. Parameter ke lambda) dan jadi Anda mendapatkan perilaku yang Anda amati. Python tidak memiliki lingkup baru implisit ini, jadi badan for for hanya membagikan variabel i.

Saya masih belum sepenuhnya yakin mengapa dalam beberapa bahasa ini bekerja satu arah, dan dalam beberapa cara lain. Dalam Common Lisp itu seperti Python:

(defvar *flist* '())

(dotimes (i 3 t)
  (setf *flist* 
    (cons (lambda (x) (* x i)) *flist*)))

(dolist (f *flist*)  
  (format t "~a~%" (funcall f 2)))

Mencetak "6 6 6" (perhatikan bahwa di sini daftarnya adalah dari 1 hingga 3, dan dibangun secara terbalik "). Sementara di Skema berfungsi seperti di Perl:

(define flist '())

(do ((i 1 (+ 1 i)))
    ((>= i 4))
  (set! flist 
    (cons (lambda (x) (* i x)) flist)))

(map 
  (lambda (f)
    (printf "~a~%" (f 2)))
  flist)

Cetakan "6 4 2"

Dan seperti yang telah saya sebutkan, Javascript ada di Python / CL camp. Tampaknya ada keputusan implementasi di sini, yang pendekatan bahasa berbeda dengan cara yang berbeda. Saya ingin sekali memahami apa keputusannya.

Masalahnya adalah bahwa semua fungsi lokal mengikat ke lingkungan yang sama dan dengan demikian ke ivariabel yang sama . Solusinya (solusinya) adalah membuat lingkungan yang terpisah (stack frames) untuk setiap fungsi (atau lambda):

t = [ (lambda x: lambda y : x*y)(x) for x in range(5)]

>>> t[1](2)
2
>>> t[2](2)
4

Variabelnya iadalah global, yang nilainya 2 pada setiap kali fungsi fdipanggil.

Saya akan cenderung menerapkan perilaku yang Anda cari sebagai berikut:

>>> class f:
...  def __init__(self, multiplier): self.multiplier = multiplier
...  def __call__(self, multiplicand): return self.multiplier*multiplicand
... 
>>> flist = [f(i) for i in range(3)]
>>> [g(2) for g in flist]
[0, 2, 4]

Respons terhadap pembaruan Anda : Bukan globalitas i per se yang menyebabkan perilaku ini, melainkan fakta bahwa itu adalah variabel dari cakupan terlampir yang memiliki nilai tetap selama waktu ketika f dipanggil. Dalam contoh kedua Anda, nilai idiambil dari ruang lingkup kkkfungsi, dan tidak ada yang berubah ketika Anda memanggil fungsi flist.

Alasan di balik perilaku telah dijelaskan, dan beberapa solusi telah diposting, tetapi saya pikir ini adalah yang paling pythonic (ingat, segala sesuatu di Python adalah objek!):

flist = []

for i in xrange(3):
    def func(x): return x * func.i
    func.i=i
    flist.append(func)

for f in flist:
    print f(2)

Jawaban Claudiu cukup bagus, menggunakan generator fungsi, tetapi jawaban piro adalah hack, jujur, karena itu membuat saya menjadi argumen "tersembunyi" dengan nilai default (itu akan berfungsi dengan baik, tetapi itu bukan "pythonic") .