Wie funktionieren lexikalische Verschlüsse?

Während ich ein Problem untersuchte, das ich mit lexikalischen Abschlüssen in Javascript-Code hatte, stieß ich in Python auf dieses Problem:

flist = []

for i in xrange(3):
    def func(x): return x * i
    flist.append(func)

for f in flist:
    print f(2)

Beachten Sie, dass dieses Beispiel achtsam vermeidet lambda. Es druckt "4 4 4", was überraschend ist. Ich würde "0 2 4" erwarten.

Dieser äquivalente Perl-Code macht es richtig:

my @flist = ();

foreach my $i (0 .. 2)
{
    push(@flist, sub {$i * $_[0]});
}

foreach my $f (@flist)
{
    print $f->(2), "\n";
}

"0 2 4" wird gedruckt.

Können Sie bitte den Unterschied erklären?

Aktualisieren:

Das Problem ist nicht mit iglobal sein. Dies zeigt das gleiche Verhalten:

flist = []

def outer():
    for i in xrange(3):
        def inner(x): return x * i
        flist.append(inner)

outer()
#~ print i   # commented because it causes an error

for f in flist:
    print f(2)

Wie die kommentierte Zeile zeigt, iist zu diesem Zeitpunkt unbekannt. Trotzdem wird "4 4 4" gedruckt.

Python verhält sich tatsächlich wie definiert. Es werden drei separate Funktionen erstellt, die jedoch jeweils die Umgebung schließen, in der sie definiert sind - in diesem Fall die globale Umgebung (oder die Umgebung der äußeren Funktion, wenn die Schleife in einer anderen Funktion platziert ist). Dies ist jedoch genau das Problem - in dieser Umgebung ist ich mutiert und die Verschlüsse beziehen sich alle auf dasselbe i .

Hier ist die beste Lösung, die ich finden kann - erstellen Sie einen Funktionsersteller und rufen Sie diesen stattdessen auf. Dies erzwingt unterschiedliche Umgebungen für jede der erstellten Funktionen mit jeweils einem anderen i .

flist = []

for i in xrange(3):
    def funcC(j):
        def func(x): return x * j
        return func
    flist.append(funcC(i))

for f in flist:
    print f(2)

Dies passiert, wenn Sie Nebenwirkungen und funktionale Programmierung mischen.

Die in der Schleife definierten Funktionen greifen weiterhin auf dieselbe Variable zu, iwährend sich ihr Wert ändert. Am Ende der Schleife zeigen alle Funktionen auf dieselbe Variable, die den letzten Wert in der Schleife enthält: Der Effekt ist der im Beispiel angegebene.

Um iseinen Wert auszuwerten und zu verwenden, wird er häufig als Parameterstandard festgelegt: Parameterstandards werden ausgewertet, wenn die defAnweisung ausgeführt wird, und daher wird der Wert der Schleifenvariablen eingefroren.

Folgendes funktioniert wie erwartet:

flist = []

for i in xrange(3):
    def func(x, i=i): # the *value* of i is copied in func() environment
        return x * i
    flist.append(func)

for f in flist:
    print f(2)

So machen Sie es mit der functoolsBibliothek (von der ich nicht sicher bin, ob sie zum Zeitpunkt der Fragestellung verfügbar war).

from functools import partial

flist = []

def func(i, x): return x * i

for i in xrange(3):
    flist.append(partial(func, i))

for f in flist:
    print f(2)

Gibt erwartungsgemäß 0 2 4 aus.

Schau dir das an:

for f in flist:
    print f.func_closure


(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)
(<cell at 0x00C980B0: int object at 0x009864B4>,)

Dies bedeutet, dass alle auf dieselbe i-Variableninstanz verweisen, die nach Beendigung der Schleife den Wert 2 hat.

Eine lesbare Lösung:

for i in xrange(3):
        def ffunc(i):
            def func(x): return x * i
            return func
        flist.append(ffunc(i))

Was passiert ist, dass die Variable i erfasst wird und die Funktionen den Wert zurückgeben, an den sie zum Zeitpunkt des Aufrufs gebunden ist. In funktionalen Sprachen tritt diese Art von Situation nie auf, da ich nicht zurückprallen würde. Bei Python und auch bei Lisp ist dies jedoch nicht mehr der Fall.

Der Unterschied zu Ihrem Schema-Beispiel besteht in der Semantik der do-Schleife. Das Schema erstellt effektiv jedes Mal eine neue i-Variable durch die Schleife, anstatt eine vorhandene i-Bindung wie bei den anderen Sprachen wiederzuverwenden. Wenn Sie eine andere Variable verwenden, die außerhalb der Schleife erstellt und mutiert wurde, wird im Schema dasselbe Verhalten angezeigt. Versuchen Sie, Ihre Schleife durch Folgendes zu ersetzen:

(let ((ii 1)) (
  (do ((i 1 (+ 1 i)))
      ((>= i 4))
    (set! flist 
      (cons (lambda (x) (* ii x)) flist))
    (set! ii i))
))

Schauen Sie hier, um weitere Diskussionen darüber zu führen.

[Bearbeiten] Möglicherweise ist es besser, sich die do-Schleife als ein Makro vorzustellen, das die folgenden Schritte ausführt:

1. Definieren Sie ein Lambda anhand eines einzelnen Parameters (i), wobei ein Körper durch den Körper der Schleife definiert wird.
2. Ein sofortiger Aufruf dieses Lambda mit entsprechenden Werten von i als Parameter.

dh. das Äquivalent zu der folgenden Python:

flist = []

def loop_body(i):      # extract body of the for loop to function
    def func(x): return x*i
    flist.append(func)

map(loop_body, xrange(3))  # for i in xrange(3): body

Das i ist nicht mehr das aus dem übergeordneten Bereich, sondern eine brandneue Variable in ihrem eigenen Bereich (dh der Parameter für das Lambda), sodass Sie das beobachtete Verhalten erhalten. Python hat diesen impliziten neuen Bereich nicht, daher teilt der Hauptteil der for-Schleife nur die Variable i.

Ich bin immer noch nicht ganz davon überzeugt, warum dies in einigen Sprachen so und auf andere Weise funktioniert. In Common Lisp ist es wie in Python:

(defvar *flist* '())

(dotimes (i 3 t)
  (setf *flist* 
    (cons (lambda (x) (* x i)) *flist*)))

(dolist (f *flist*)  
  (format t "~a~%" (funcall f 2)))

Druckt "6 6 6" (beachten Sie, dass hier die Liste von 1 bis 3 ist und umgekehrt aufgebaut ist "). Während in Schema funktioniert es wie in Perl:

(define flist '())

(do ((i 1 (+ 1 i)))
    ((>= i 4))
  (set! flist 
    (cons (lambda (x) (* i x)) flist)))

(map 
  (lambda (f)
    (printf "~a~%" (f 2)))
  flist)

Druckt "6 4 2"

Und wie ich bereits erwähnt habe, befindet sich Javascript im Python / CL-Camp. Es scheint, dass es hier eine Implementierungsentscheidung gibt, die verschiedene Sprachen auf unterschiedliche Weise angehen. Ich würde gerne genau verstehen, was die Entscheidung ist.

Das Problem ist, dass alle lokalen Funktionen an dieselbe Umgebung und damit an dieselbe iVariable gebunden sind. Die Lösung (Problemumgehung) besteht darin, für jede Funktion (oder jedes Lambda) separate Umgebungen (Stapelrahmen) zu erstellen:

t = [ (lambda x: lambda y : x*y)(x) for x in range(5)]

>>> t[1](2)
2
>>> t[2](2)
4

Die Variable iist eine globale Variable , deren Wert bei jedem fAufruf der Funktion 2 beträgt.

Ich wäre geneigt, das Verhalten, nach dem Sie suchen, wie folgt umzusetzen:

>>> class f:
...  def __init__(self, multiplier): self.multiplier = multiplier
...  def __call__(self, multiplicand): return self.multiplier*multiplicand
... 
>>> flist = [f(i) for i in range(3)]
>>> [g(2) for g in flist]
[0, 2, 4]

Antwort auf Ihr Update : Es ist nicht die Globalität an i sich, die dieses Verhalten verursacht, sondern die Tatsache, dass es sich um eine Variable aus einem umschließenden Bereich handelt, die über die Zeiten, in denen f aufgerufen wird, einen festen Wert hat. In Ihrem zweiten Beispiel wird der Wert von iaus dem kkkFunktionsumfang übernommen, und daran ändert sich nichts, wenn Sie die Funktionen aufrufen flist.

Die Gründe für das Verhalten wurden bereits erklärt und es wurden mehrere Lösungen veröffentlicht, aber ich denke, dies ist die pythonischste (denken Sie daran, alles in Python ist ein Objekt!):

flist = []

for i in xrange(3):
    def func(x): return x * func.i
    func.i=i
    flist.append(func)

for f in flist:
    print f(2)

Claudius Antwort ist ziemlich gut, wenn man einen Funktionsgenerator verwendet, aber Piros Antwort ist ein Hack, um ehrlich zu sein, da es mich zu einem "versteckten" Argument mit einem Standardwert macht (es wird gut funktionieren, aber es ist nicht "pythonisch"). .