Wie erstelle ich eine Liste von Python Lambda-Ausdrücke (in einer Liste verstehen/for-Schleife)?

Ich vermute, dass die lambda-Sie erstellen in der Liste der Verständigung gebunden an die variable i, die schließlich landet auf 5. Also, wenn Sie bewerten den lambdas nach die Tatsache, dass Sie alle gebunden sind, 5 und am Ende der Berechnung 25. Das gleiche geschieht mit der num in deinem zweiten Beispiel. Wenn Sie bewerten den lambda-Ausdruck innerhalb der Schleife ist es num hat sich nicht geändert, so dass Sie die richtige Wert. Nach der Schleife, num 5...

Ich bin mir nicht ganz sicher, was Sie für gehen, so bin ich nicht sicher, wie Sie Sie vorschlagen, eine Lösung. Wie wäre es damit?

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

Das gibt mir die erwartete Ausgabe:

1
4
9
16
25

Einen anderen Weg, dies zu betrachten ist, dass ein lambda "erfasst", seine lexikalische Umgebung an der Stelle, wo es erstellt wird. Also, wenn Sie geben es num es nicht wirklich beheben, dass Wert, bis Ihr aufgerufen. Dies ist sowohl verwirrend und mächtig.

Wenn-Funktion-Anweisungen ausgeführt werden, sind Sie verpflichtet, Ihre (lexikalisch) umschließenden scope.

In Ihrem snippet, der Lambda-Ausdrücke gebunden sind, um den globalen scope, weil for Suiten sind nicht ausgeführt, wie eine unabhängig Gültigkeitsbereich Einheit in Python. Am Ende der for Schleife, die num gebunden ist, in den umschließenden scope. Demo:

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

Also beim binden von Bezeichnern, die for Schleife bist du eigentlich mit der Manipulation der umschließenden scope.

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

Gleiche Angebot für die Liste Verstehens:

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

Geist weht, ich weiß. Anywho, mit unserem neu gewonnenen wissen, können wir feststellen, dass die Lambda-Ausdrücke, die Sie erstellen, werden auf der (einzigen) num Bezeichner gebunden in den umschließenden scope. Sollte dies mehr Sinn machen:

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)

Und hier ist das coolste Teil, die es zeigt noch mehr:

# 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) 

So die Lösung von dieser, natürlich, ist es, eine neue umschließenden Bereich für jeden number Sie binden möchten. In Python können Sie neue umschließenden Bereiche mit Modulen, Klassen und Funktionen. Es ist üblich, eine Funktion verwenden, nur zum erstellen neuer umschließenden scope, der für eine andere Funktion.

In Python, ein Schließung ist eine Funktion, die gibt eine weitere Funktion. Wie eine Art Konstruktor-Funktion. Check-out get_fun im folgenden Beispiel:

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)

Seit get_fun ist eine Funktion, die es bekommt seinen eigenen internen Bereich. Jedes mal, wenn Sie rufen get_fun mit einem Wert, der eine kleine Tabelle erstellt, um zu verfolgen Bindungen in ihm; d.h. er sagt, "In diesem Rahmen, die value identifier Punkte auf die Sache, die übergeben wurde." Dieser Bereich geht Weg am Ende der Ausführung der Funktion, es sei denn, es gibt einen Grund für Sie, um zu hängen.

Wenn Sie der Rückgabe einer Funktion innerhalb eines Bereichs, das ist ein guter Grund für Teile der "Rahmen-Tabelle" herum zu hängen,--, die Funktion, die Sie zurückgeben könnte, Referenz Sachen aus diesem Bereich der Tabelle, wenn Sie rufen Sie es später. Aus diesem Grund, wenn fun in get_fun Python erzählt fun über get_fun's scope-Tabelle, die fun hält, praktisch, wenn' s nötig ist.

Lesen Sie mehr über die details und technische Terminologie (die ich erweicht ein bisschen) in die Python-docs auf dem Ausführungsmodell. Sie können auch einen Blick auf die Teile der umschließenden scope, der eine Funktion bezeichnet, mit print fun.__closure__. In dem obigen sehen wir, dass der Verweis auf die value,, die passiert werden die ein int:

# 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>,)

Finde ich manchmal, dass die Festlegung der tatsächlichen Klassen, die für die Funktion Objekte macht es einfacher zu verstehen, was Los ist:

>>> 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
>>>

Zugegeben, es ist ein wenig Ausführlicher als die Verwendung von Lambda-Ausdrücke oder closures, aber ich finde diese leichter zu verstehen, wenn ich versuche zu tun, nicht offensichtliche Dinge, die mit Funktionen.

Könnten Sie auch tun:

>>> 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]