ขอบเขตของฟังก์ชันแลมด้าและพารามิเตอร์?

ฉันต้องการฟังก์ชั่นการโทรกลับที่เกือบจะเหมือนกันทุกประการสำหรับชุดกิจกรรม gui ฟังก์ชันจะทำงานแตกต่างกันเล็กน้อยขึ้นอยู่กับเหตุการณ์ที่เรียกมัน ดูเหมือนจะเป็นกรณีธรรมดาสำหรับฉัน แต่ฉันไม่สามารถเข้าใจพฤติกรรมแปลก ๆ ของฟังก์ชันแลมด้านี้ได้

ดังนั้นฉันจึงมีโค้ดแบบง่ายต่อไปนี้ด้านล่าง:

def callback(msg):
    print msg

#creating a list of function handles with an iterator
funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(lambda: callback(m))
for f in funcList:
    f()

#create one at a time
funcList=[]
funcList.append(lambda: callback('do'))
funcList.append(lambda: callback('re'))
funcList.append(lambda: callback('mi'))
for f in funcList:
    f()

ผลลัพธ์ของรหัสนี้คือ:

mi
mi
mi
do
re
mi

ฉันคาดหวัง:

do
re
mi
do
re
mi

เหตุใดการใช้ iterator จึงทำให้สิ่งต่างๆยุ่งเหยิง

ฉันได้ลองใช้ deepcopy:

import copy
funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(lambda: callback(copy.deepcopy(m)))
for f in funcList:
    f()

แต่นี่ก็มีปัญหาเหมือนกัน

ปัญหาคือmตัวแปร (ข้อมูลอ้างอิง) ที่ถูกนำมาจากขอบเขตรอบข้าง เฉพาะพารามิเตอร์เท่านั้นที่อยู่ในขอบเขตแลมบ์ดา

ในการแก้ปัญหานี้คุณต้องสร้างขอบเขตอื่นสำหรับแลมด้า:

def callback(msg):
    print msg

def callback_factory(m):
    return lambda: callback(m)

funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(callback_factory(m))
for f in funcList:
    f()

ในตัวอย่างข้างต้นแลมบ์ดายังใช้ขอบเขตที่คาดเดาได้ในการค้นหาmแต่คราวนี้เป็นcallback_factoryขอบเขตที่สร้างขึ้นหนึ่งครั้งต่อการcallback_factory โทรทุกครั้ง

หรือด้วยfunctools.partial :

from functools import partial

def callback(msg):
    print msg

funcList=[partial(callback, m) for m in ('do', 're', 'mi')]
for f in funcList:
    f()

เมื่อสร้างแลมบ์ดาจะไม่สร้างสำเนาของตัวแปรในขอบเขตการปิดล้อมที่ใช้ มันรักษาการอ้างอิงถึงสภาพแวดล้อมเพื่อให้สามารถค้นหาค่าของตัวแปรได้ในภายหลัง mมีเพียงหนึ่ง จะได้รับมอบหมายให้ทุกครั้งผ่านลูป หลังจากที่วงตัวแปรมีค่าm 'mi'ดังนั้นเมื่อคุณเรียกใช้ฟังก์ชันที่คุณสร้างขึ้นในภายหลังมันจะค้นหาค่าmในสภาพแวดล้อมที่สร้างขึ้นซึ่งจะมีค่า'mi'อยู่ในสภาพแวดล้อมที่สร้างมันซึ่งจากนั้นจะมีค่า

วิธีแก้ปัญหาทั่วไปและสำนวนหนึ่งสำหรับปัญหานี้คือการจับค่าของmเวลาที่สร้างแลมบ์ดาโดยใช้เป็นอาร์กิวเมนต์เริ่มต้นของพารามิเตอร์ที่เป็นทางเลือก โดยปกติคุณจะใช้พารามิเตอร์ที่มีชื่อเดียวกันดังนั้นคุณจึงไม่จำเป็นต้องเปลี่ยนเนื้อหาของโค้ด:

for m in ('do', 're', 'mi'):
    funcList.append(lambda m=m: callback(m))

Python ใช้การอ้างอิงแน่นอน แต่ไม่สำคัญในบริบทนี้

เมื่อคุณกำหนดแลมบ์ดา (หรือฟังก์ชันเนื่องจากนี่เป็นลักษณะการทำงานเดียวกันทุกประการ) จะไม่ประเมินนิพจน์แลมด้าก่อนรันไทม์:

# defining that function is perfectly fine
def broken():
    print undefined_var

broken() # but calling it will raise a NameError

น่าแปลกใจยิ่งกว่าตัวอย่างแลมด้าของคุณ:

i = 'bar'
def foo():
    print i

foo() # bar

i = 'banana'

foo() # you would expect 'bar' here? well it prints 'banana'

ในระยะสั้นคิดว่าไดนามิก: ไม่มีการประเมินก่อนการตีความนั่นคือสาเหตุที่โค้ดของคุณใช้ค่าล่าสุดของ m

เมื่อมองหา m ในการดำเนินการแลมบ์ดา m จะถูกนำมาจากขอบเขตบนสุดซึ่งหมายความว่าตามที่คนอื่น ๆ ชี้ให้เห็น คุณสามารถหลีกเลี่ยงปัญหานั้นได้โดยเพิ่มขอบเขตอื่น:

def factory(x):
    return lambda: callback(x)

for m in ('do', 're', 'mi'):
    funcList.append(factory(m))

ที่นี่เมื่อมีการเรียกแลมบ์ดามันจะดูในขอบเขตนิยามแลมบ์ดาสำหรับ x x นี้เป็นตัวแปรท้องถิ่นที่กำหนดไว้ในตัวของโรงงาน ด้วยเหตุนี้ค่าที่ใช้ในการดำเนินการแลมบ์ดาจะเป็นค่าที่ส่งผ่านเป็นพารามิเตอร์ระหว่างการเรียกไปยังโรงงาน และโดเรมี!

ตามหมายเหตุฉันสามารถกำหนดโรงงานเป็นโรงงาน (m) [แทนที่ x ด้วย m] พฤติกรรมก็เหมือนกัน ฉันใช้ชื่ออื่นเพื่อความชัดเจน :)

คุณอาจพบว่าAndrej Bauerมีปัญหาแลมด้าที่คล้ายกัน สิ่งที่น่าสนใจในบล็อกนั้นคือความคิดเห็นซึ่งคุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับการปิด python :)

ไม่เกี่ยวข้องโดยตรงกับปัญหาที่อยู่ในมือ แต่เป็นภูมิปัญญาล้ำค่าอย่างไรก็ตามPython Objectsโดย Fredrik Lundh

ใช่นั่นเป็นปัญหาของขอบเขตมันผูกกับ m ภายนอกไม่ว่าคุณจะใช้แลมด้าหรือฟังก์ชันโลคัล ใช้ functor แทน:

class Func1(object):
    def __init__(self, callback, message):
        self.callback = callback
        self.message = message
    def __call__(self):
        return self.callback(self.message)
funcList.append(Func1(callback, m))

โซลิตันถึงแลมบ์ดาเป็นแลมด้ามากกว่า

In [0]: funcs = [(lambda j: (lambda: j))(i) for i in ('do', 're', 'mi')]

In [1]: funcs
Out[1]: 
[<function __main__.<lambda>>,
 <function __main__.<lambda>>,
 <function __main__.<lambda>>]

In [2]: [f() for f in funcs]
Out[2]: ['do', 're', 'mi']

ด้านนอกlambdaใช้เพื่อผูกค่าปัจจุบันของiถึงj ที่

ในแต่ละครั้งที่ด้านนอกlambdaที่เรียกว่ามันทำให้ตัวอย่างของภายในlambdaกับjผูกไว้กับค่าปัจจุบันของiเป็นiค่า 's

อันดับแรกสิ่งที่คุณเห็นไม่ใช่ปัญหาและไม่เกี่ยวข้องกับการเรียกตามการอ้างอิงหรือตามค่า

ไวยากรณ์แลมบ์ดาที่คุณกำหนดไม่มีพารามิเตอร์ดังนั้นขอบเขตที่คุณเห็นด้วยพารามิเตอร์ mจึงอยู่ภายนอกของฟังก์ชันแลมบ์ดา นี่คือเหตุผลที่คุณเห็นผลลัพธ์เหล่านี้

ไวยากรณ์ Lambda ในตัวอย่างของคุณไม่จำเป็นและคุณต้องการใช้การเรียกใช้ฟังก์ชันง่ายๆ:

for m in ('do', 're', 'mi'):
    callback(m)

ขอย้ำอีกครั้งว่าคุณใช้พารามิเตอร์แลมบ์ดาอย่างชัดเจนและขอบเขตเริ่มต้นและสิ้นสุดที่ใด

เป็นหมายเหตุด้านข้างเกี่ยวกับการส่งผ่านพารามิเตอร์ พารามิเตอร์ใน python อ้างอิงถึงวัตถุเสมอ เพื่ออ้างถึง Alex Martelli:

ปัญหาเกี่ยวกับศัพท์อาจเกิดจากข้อเท็จจริงที่ว่าใน python ค่าของชื่อเป็นการอ้างอิงถึงวัตถุ ดังนั้นคุณมักจะส่งผ่านค่า (ไม่มีการคัดลอกโดยนัย) และค่านั้นจะเป็นข้อมูลอ้างอิงเสมอ [... ] ตอนนี้ถ้าคุณต้องการเหรียญชื่อสำหรับสิ่งนั้นเช่น "โดยการอ้างอิงวัตถุ" "ตามค่าที่ไม่ได้คัดลอก" หรืออะไรก็ตามเป็นแขกของฉัน การพยายามใช้คำศัพท์ซ้ำที่มักใช้กับภาษาที่ "ตัวแปรเป็นกล่อง" กับภาษาที่ "ตัวแปรเป็นแท็กโพสต์อิท" คือ IMHO มีแนวโน้มที่จะสับสนมากกว่าที่จะช่วยได้

ตัวแปร mกำลังจับดังนั้นนิพจน์แลมบ์ดาของคุณจะเห็นค่า "ปัจจุบัน" เสมอ

หากคุณต้องการจับค่าอย่างมีประสิทธิภาพในช่วงเวลาหนึ่งให้เขียนฟังก์ชันรับค่าที่คุณต้องการเป็นพารามิเตอร์และส่งกลับนิพจน์แลมบ์ดา เมื่อถึงจุดนั้นแลมด้าจะจับค่าของพารามิเตอร์ซึ่งจะไม่เปลี่ยนแปลงเมื่อคุณเรียกใช้ฟังก์ชันหลายครั้ง:

def callback(msg):
    print msg

def createCallback(msg):
    return lambda: callback(msg)

#creating a list of function handles with an iterator
funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(createCallback(m))
for f in funcList:
    f()

เอาท์พุต:

do
re
mi

ไม่มีตัวแปรในความหมายคลาสสิกใน Python มีเพียงชื่อที่ถูกผูกไว้โดยการอ้างอิงถึงวัตถุที่เกี่ยวข้อง แม้แต่ฟังก์ชั่นก็เป็นวัตถุบางประเภทใน Python และ lambdas ไม่ได้ยกเว้นกฎ :)

ในฐานะที่เป็นข้อสังเกตด้านข้างmapแม้ว่าจะดูหมิ่นร่าง Python ที่รู้จักกันดี แต่ก็บังคับให้มีการก่อสร้างที่ป้องกันข้อผิดพลาดนี้

fs = map (lambda i: lambda: callback (i), ['do', 're', 'mi'])

หมายเหตุ: ข้อแรกlambda iทำตัวเหมือนโรงงานในคำตอบอื่น ๆ