(Lambda) fonksiyon kapakları ne yakalar?

Son zamanlarda Python ile oynamaya başladım ve kapakların çalışma biçimine özgü bir şey ortaya çıktı. Aşağıdaki kodu göz önünde bulundurun:

adders=[0,1,2,3]

for i in [0,1,2,3]:
   adders[i]=lambda a: i+a

print adders[1](3)

Tek bir girdi alan ve bir sayı tarafından eklenen girdiyi döndüren basit bir işlev dizisi oluşturur. İşlevler for, yineleyicinin ila iarasında çalıştığı döngüde 0oluşturulur 3. Bu sayıların her biri için onu lambdayakalayan ive işlevin girişine ekleyen bir işlev oluşturulur . Son satır ikinci lambdafonksiyonu 3parametre olarak çağırır . Benim için sürpriz çıktı 6.

Beklediğim bir 4. Benim mantığım şuydu: Python'da her şey bir nesnedir ve bu nedenle her değişken onun için bir göstergedir. İçin lambdakapanışları oluştururken i, şu anda işaret ettiği tamsayı nesnesine bir işaretçi saklamasını bekledim i. Bu, iyeni bir tamsayı nesnesi atandığında, önceden oluşturulan kapanmaları etkilememesi gerektiği anlamına gelir . Ne yazık ki, addersdiziyi bir hata ayıklayıcı içinde incelemek, bunu yaptığını gösterir. Tüm lambdafonksiyonlar son değerine bakın i, 3içinde, hangi sonuçların adders[1](3)dönen 6.

Hangi beni merak ediyorsun:

• Kapaklar tam olarak ne yakalar?
• lambdaİşlevleri , değerini değiştirdiğinde ietkilenmeyecek şekilde , geçerli değerini yakalamaya ikna etmenin en zarif yolu nedir i?

İkinci sorunuz cevaplandı, ancak ilk soruya gelince:

kapak tam olarak ne yakalar?

Python'da kapsam belirleme dinamik ve sözcükseldir. Bir kapatma, işaret ettiği nesneyi değil, değişkenin adını ve kapsamını her zaman hatırlar. Örneğinizdeki tüm işlevler aynı kapsamda oluşturulduğundan ve aynı değişken adını kullandığından, her zaman aynı değişkene başvururlar.

EDIT: Bunun üstesinden gelmekle ilgili diğer sorunuzla ilgili olarak, akla gelen iki yol vardır:

1. En özlü, ama kesinlikle eşdeğer olmayan yol Adrien Plisson tarafından önerilen yöntemdir . Fazladan bağımsız değişken içeren bir lambda oluşturun ve fazladan bağımsız değişkenin varsayılan değerini korunmasını istediğiniz nesneye ayarlayın.

2. Lambda'yı her oluşturduğunuzda yeni bir kapsam oluşturmak için biraz daha ayrıntılı ama daha az hileli olurdu:

   >>> adders = [0,1,2,3]
   >>> for i in [0,1,2,3]:
   ...     adders[i] = (lambda b: lambda a: b + a)(i)
   ...     
   >>> adders[1](3)
   4
   >>> adders[2](3)
   5

   Buradaki kapsam, bağımsız değişkenini bağlayan ve bağımsız değişken olarak bağlamak istediğiniz değeri geçiren yeni bir işlev (kısalık için bir lambda) kullanılarak oluşturulur. Gerçek kodda, yeni kapsamı oluşturmak için muhtemelen lambda yerine sıradan bir işleve sahip olacaksınız:

   def createAdder(x):
       return lambda y: y + x
   adders = [createAdder(i) for i in range(4)]

varsayılan değere sahip bir argüman kullanarak bir değişkenin yakalanmasını zorlayabilirsiniz:

>>> for i in [0,1,2,3]:
...    adders[i]=lambda a,i=i: i+a  # note the dummy parameter with a default value
...
>>> print( adders[1](3) )
4

Fikir bir parametre bildirmek (akıllıca adlandırılmış olan i) ve bir daha yakalama istediğiniz değişkenin varsayılan değeri (değeri vermek i)

Bütünlüğü için ikinci soruya başka cevap: Sen kullanabilirsiniz kısmi de functools modülü.

Chris Lutz'ın önerdiği gibi operatörden ekleme ekleyerek örnek şöyle olur:

from functools import partial
from operator import add   # add(a, b) -- Same as a + b.

adders = [0,1,2,3]
for i in [0,1,2,3]:
   # store callable object with first argument given as (current) i
   adders[i] = partial(add, i) 

print adders[1](3)

Aşağıdaki kodu göz önünde bulundurun:

x = "foo"

def print_x():
    print x

x = "bar"

print_x() # Outputs "bar"

Çoğu insanın bu kafa karıştırıcıyı hiç bulamayacağını düşünüyorum. Beklenen davranıştır.

Peki, insanlar neden bir döngü içinde yapıldığında bunun farklı olacağını düşünüyor? Bu hatayı kendim yaptığımı biliyorum, ama nedenini bilmiyorum. Döngü mü? Ya da belki lambda?

Sonuçta, döngü sadece daha kısa bir versiyonudur:

adders= [0,1,2,3]
i = 0
adders[i] = lambda a: i+a
i = 1
adders[i] = lambda a: i+a
i = 2
adders[i] = lambda a: i+a
i = 3
adders[i] = lambda a: i+a

İkinci sorunuza yanıt olarak, bunu yapmanın en zarif yolu, bir dizi yerine iki parametre alan bir işlev kullanmak olacaktır:

add = lambda a, b: a + b
add(1, 3)

Ancak, burada lambda kullanmak biraz saçma. Python bize operatortemel operatörlere fonksiyonel bir arayüz sağlayan modülü veriyor . Yukarıdaki lambda'nın sadece ekleme operatörünü çağırmak için gereksiz yükü vardır:

from operator import add
add(1, 3)

Etrafta oynadığınızı, dili keşfetmeye çalıştığınızı anlıyorum, ancak Python'un kapsam tuhaflığının önüne geçeceği bir dizi işlevi kullanacağımı hayal edemiyorum.

İsterseniz dizi dizine ekleme sözdiziminizi kullanan küçük bir sınıf yazabilirsiniz:

class Adders(object):
    def __getitem__(self, item):
        return lambda a: a + item

adders = Adders()
adders[1](3)

Burada, kapalı bağlamın "kaydedildiğini" açıklığa kavuşturmaya yardımcı olması için bir kapağın veri yapısını ve içeriğini vurgulayan yeni bir örnek verilmiştir.

def make_funcs():
    i = 42
    my_str = "hi"

    f_one = lambda: i

    i += 1
    f_two = lambda: i+1

    f_three = lambda: my_str
    return f_one, f_two, f_three

f_1, f_2, f_3 = make_funcs()

Kapanışta ne var?

>>> print f_1.func_closure, f_1.func_closure[0].cell_contents
(<cell at 0x106a99a28: int object at 0x7fbb20c11170>,) 43 

Özellikle, my_str f1'in kapanışında değil.

F2'nin kapanmasında neler var?

>>> print f_2.func_closure, f_2.func_closure[0].cell_contents
(<cell at 0x106a99a28: int object at 0x7fbb20c11170>,) 43

Her iki kapağın da aynı nesneleri içerdiğine (bellek adreslerinden) dikkat edin. Böylece başlayabilirsiniz lambda fonksiyonunu kapsama referans olarak düşünmeye . Ancak, my_str, f_1 veya f_2 için kapanışta değil ve i, kapatma nesnelerinin kendilerinin ayrı nesneler olduğunu gösteren f_3 (gösterilmiyor) için kapanışta değil.

Kapatma nesneleri kendileri aynı nesne midir?

>>> print f_1.func_closure is f_2.func_closure
False