Сфера застосування лямбда-функцій та їх параметрів?

Мені потрібна функція зворотного виклику, яка майже однакова для серії подій графічного інтерфейсу. Функція буде поводитися дещо інакше, залежно від того, яка подія її викликала. Мені здається простим випадком, але я не можу зрозуміти цю дивну поведінку лямбда-функцій.

Отже, у мене є такий спрощений код нижче:

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

Чому використання ітератора заплутало речі?

Я спробував скористатися глибокою копією:

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], поведінка однакова. Я використовував іншу назву для наочності :)

Ви можете виявити, що Андрій Бауер мав подібні лямбда-проблеми. Що цікаво в цьому блозі - це коментарі, де ви дізнаєтесь більше про закриття python :)

Не пов’язаний безпосередньо з розглянутою проблемою, але тим не менш безцінна мудрість: об’єкти Python Фредріка Лунда

Так, це проблема сфери дії, вона прив'язується до зовнішнього m, незалежно від того, використовуєте ви лямбда-функцію або локальну функцію. Натомість використовуйте функтор:

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є зовнішньою для функції лямбда. Ось чому ви бачите ці результати.

Лямбда-синтаксис у вашому прикладі не потрібен, і ви скоріше використовуєте простий виклик функції:

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

Знову ж таки, ви повинні бути дуже точними щодо того, які лямбда-параметри ви використовуєте, і де саме починається і закінчується їх область дії.

Як додаткове зауваження щодо передачі параметрів. Параметри в python - це завжди посилання на об'єкти. Процитувавши Алекса Мартеллі:

Проблема термінології може бути пов’язана з тим, що в python значення імені є посиланням на об’єкт. Отже, ви завжди передаєте значення (без неявного копіювання), і це значення завжди є посиланням. [...] Тепер, якщо ви хочете назвати ім’я для цього, наприклад, «за посиланням на об’єкт», «за не скопійованим значенням» чи будь-яке інше, будьте моїм гостем. Спроба повторно використати термінологію, яка в більшій мірі застосовується до мов, де "змінні - це поля", до мови, де "змінні - це теги post-it", 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, і лямбди не роблять винятку з правила :)

Як допоміжна примітка, mapхоча і зневажається деякими відомими діячами Пітона, змушує споруду, яка запобігає цій пастці.

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

Примітка. Перша lambda iдія відповідає фабриці в інших відповідях.