Как мне создать список лямбда-выражений Python (в цикле понимания / для списка)? - PullRequest
33 голосов
/ 17 января 2009

Я хочу создать список лямбда-объектов из списка констант в Python; например:

listOfNumbers = [1,2,3,4,5]
square = lambda x: x * x
listOfLambdas = [lambda: square(i) for i in listOfNumbers]

Это создаст список лямбда-объектов, однако, при запуске их:

for f in listOfLambdas:
    print f(),

Я ожидаю, что он напечатает

1 4 9 16 25

Вместо этого он печатает:

25 25 25 25 25

Похоже, что лямбды получили неверный параметр. Я сделал что-то не так, и есть ли способ это исправить? Я в Python 2.4, я думаю.

РЕДАКТИРОВАТЬ: немного больше попыток, и вот что такое:

listOfLambdas = []
for num in listOfNumbers:
    action = lambda: square(num)
    listOfLambdas.append(action)
    print action()

Печать ожидаемых квадратов от 1 до 25, но затем с использованием более раннего оператора print:

for f in listOfLambdas:
    print f(),

все еще дает мне все 25 с. Как изменились существующие лямбда-объекты между этими двумя вызовами печати?

Смежный вопрос: Почему результаты map () и понимания списка различны?

Ответы [ 8 ]

24 голосов
/ 17 января 2009

У вас есть:

listOfLambdas = [lambda: i*i for i in range(6)]

for f in listOfLambdas:
    print f()

Выход:

25
25
25
25
25
25

Тебе нужно карри! Помимо того, чтобы быть восхитительным, используйте это значение по умолчанию "hack".

listOfLambdas = [lambda i=i: i*i for i in range(6)]

for f in listOfLambdas:
    print f()

Выход:

0
1
4
9
16
25

Обратите внимание на i=i. Вот где происходит магия.

20 голосов
/ 17 января 2009

Я предполагаю, что лямбда, которую вы создаете в понимании списка, привязана к переменной i, которая в конечном итоге заканчивается на 5. Таким образом, когда вы вычисляете лямбду после факта, они все связаны с 5 в итоге получим 25. То же самое происходит с num во втором примере. Когда вы вычисляете лямбду внутри цикла, ее число не изменилось, поэтому вы получите правильное значение. После цикла num равно 5 ...

Я не совсем уверен, что вы собираетесь, поэтому я не уверен, как предложить решение. Как насчет этого?

def square(x): return lambda : x*x
listOfLambdas = [square(i) for i in [1,2,3,4,5]]
for f in listOfLambdas: print f()

Это дает мне ожидаемый результат:

1
4
9
16
25

Еще один способ думать об этом заключается в том, что лямбда «захватывает» свою лексическую среду в том месте, где она создается. Таким образом, если вы дадите ему num , оно на самом деле не разрешит это значение, пока оно не будет вызвано. Это одновременно запутанно и сильно.

4 голосов
/ 17 января 2009

Когда выполняются операторы функций, они привязываются к своей (лексической) области видимости.

В вашем фрагменте лямбды привязаны к глобальной области видимости, потому что for комплекты не выполняются в Python как независимые единицы измерения. В конце цикла for, num ограничен в пределах объема. Демонстрация:

for num in range(1, 6):
    pass
assert num == 5 # num is now bound in the enclosing scope

Таким образом, когда вы связываете идентификаторы в цикле for, вы фактически манипулируете включающей областью действия.

for num in range(1, 6):
    spam = 12
assert num == 5 # num is now bound in the enclosing scope
assert spam == 12 # spam is also bound in the enclosing scope

То же самое для списочных представлений:

[num for num in range(1, 6)]
assert num == 5

Сногсшибательно, я знаю. В любом случае, благодаря нашим новым знаниям, мы можем определить, что создаваемые лямбды ссылаются на (один) идентификатор num, связанный в пределах объема. Это должно иметь больше смысла:

functions = []
for number in range(1, 6):
    def fun():
        return number
    functions.append(fun)
assert all(fun() == 5 for fun in functions)
assert all(fun() is number for fun in functions)

А вот самая крутая часть, которая демонстрирует это еще больше:

# Same as above -- commented out for emphasis.
#functions = []
#for number in range(1, 6):
#    def fun():
#        return number
#    functions.append(fun)
#assert all(fun() == 5 for fun in functions)
#assert all(fun() is number for fun in functions)
number = 6 # Rebind 6 in the scope and see how it affects the results.
assert all(fun() == 6 for fun in functions) 

Таким образом, решение этой проблемы, конечно же, заключается в создании новой ограждающей области для каждого number, который вы хотите связать. В Python вы можете создавать новые вмещающие области с модулями, классами и функциями. Обычно функцию используют для создания новой области видимости для другой функции.

В Python замыкание - это функция, которая возвращает другую функцию . Вроде как конструктор функций. Проверьте get_fun в следующем примере:

def get_fun(value):
    """:return: A function that returns :param:`value`."""
    def fun(): # Bound to get_fun's scope
        return value
    return fun

functions = []
for number in range(1, 6):
    functions.append(get_fun(number))
assert [fun() for fun in functions] == range(1, 6)

Поскольку get_fun является функцией, она имеет собственную внутреннюю область видимости. Каждый раз, когда вы вызываете get_fun со значением, создается небольшая таблица, чтобы отслеживать привязки внутри нее; то есть он говорит: «В этом объеме идентификатор value указывает на то, что было передано». Эта область исчезает в конце выполнения функции, если только у нее нет причин задерживаться.

Если вы возвращаете функцию из области действия, это хорошая причина для того, чтобы части "таблицы областей действия" зависали - эта функция, которую вы возвращаете, может ссылаться на вещи из этой таблицы области действия при последующем вызове на. По этой причине, когда fun создается в get_fun, Python сообщает fun о таблице областей действия get_fun, которая fun всегда под рукой, когда это необходимо.

Вы можете узнать больше о деталях и технической терминологии (которую я немного смягчил) в Документах Python по модели исполнения . Вы также можете посмотреть на те части окружения, на которые ссылается функция с помощью print fun.__closure__. В приведенном выше примере мы видим ссылку на value, которая является целым числом:

# Same as before, commented out for emphasis.
#functions = []
#for number in range(1, 6):
#    functions.append(get_fun(number))
#assert [fun() for fun in functions] == range(1, 6)
print functions[0].__closure__
# Produces: (<cell at 0x8dc30: int object at 0x1004188>,)
2 голосов
/ 17 января 2009
listOfLambdas = [lambda i=i: square(i) for i in listOfNumbers]

Или

listOfLambdas = map(lambda i: lambda: square(i), listOfNumbers)
1 голос
/ 15 мая 2014

Попробуйте использовать () вместо []:

listOfLambdas = (lambda: square(i) for i in listOfNumbers)

И вы получите:

1
4
9
16
25
1 голос
/ 17 января 2009

Иногда я обнаруживаю, что определение реальных классов для объектов функций облегчает понимание происходящего:

>>> class square(object):
...   def __init__(self, val):
...     self.val = val
...   def __call__(self):
...     return self.val * self.val
...
>>> l = [1,2,3,4,5]
>>> funcs = [square(i) for i in l]
>>> for f in funcs:
...   print f()
...
1
4
9
16
25
>>>

Конечно, это немного более многословно, чем использование лямбда-выражений или замыканий, но мне легче это понять, когда я пытаюсь делать неочевидные вещи с функциями.

0 голосов
/ 10 января 2017

В качестве дополнительного комментария, я хотел бы обрисовать в общих чертах возможность генерировать списки лямбда-функций из симпози матриц (я не знаю, является ли это лучшим способом сделать это, но я так и делаю, и я нахожу это удобно):

import sympy as sp
sp.var('Ksi')
# generate sympy expressions for Berstein's polynomials
B_expr = sp.Matrix([sp.binomial(3, i) * Ksi**i * (1 - Ksi)**(3-i) for i in range(4)])
# lambdify them 
B = [sp.lambdify((Ksi), B_expr[i]) for i in range(4) ]
0 голосов
/ 14 июля 2015

Вы также можете сделать:

>>> def squares():
...     for i in [1,2,3,4,5]:
...         yield lambda:i*i
... 
>>> print [square() for square in squares()]
[1, 4, 9, 16, 25]
...