Verhalten der exec-Funktion in Python 2 und Python 3

Gibt es einen großen Unterschied zwischen exec in Python 2 und exec() in Python 3. Sie behandeln exec als eine Funktion, aber es ist wirklich ein Anweisung in Python 2.

Weil dieser Differenz, die Sie nicht ändern können lokale Variablen in der Funktion Umfang in Python 3 mit exec, obwohl es möglich war, in Python 2. Auch nicht deklarierte Variablen.

locals() spiegelt lediglich die lokalen Variablen in eine Richtung. Die folgenden noch nie gearbeitet, in entweder 2 oder 3:

def foo():
    a = 'spam'
    locals()['a'] = 'ham'
    print(a)              # prints 'spam'

In Python 2, mit der exec Aussage gemeint ist der compiler wusste, dass Sie das ausschalten der local-Bereich-Optimierungen (Wechsel von LOAD_FAST zu LOAD_NAME zum Beispiel, zu suchen Variablen in lokale und Globale Bereiche). Mit exec() ist eine Funktion, die option ist nicht mehr verfügbar und die Funktion scopes sind jetzt immer optimiert.

Darüber hinaus in Python 2 die exec Anweisung explizit kopiert alle Variablen gefunden, die in locals() zurück, um die Funktion einheimischen mit PyFrame_LocalsToFast, aber nur, wenn kein globals und einheimischen Parameter geliefert wurden.

Die richtige work-around ist, verwenden Sie einen neuen namespace (ein Wörterbuch) für Ihre exec() nennen:

def execute(a, st):
    namespace = {}
    exec("b = {}\nprint('b:', b)".format(st), namespace)
    print(namespace['b'])

Den exec() - Dokumentation ist sehr explizit über diese Einschränkung:

Hinweis: Die Standard - einheimischen wie oben beschrieben für die Funktion locals() unten: änderungen an der Standard - einheimischen Wörterbuch sollte nicht versucht werden. Pass eine explizite einheimischen Wörterbuch, wenn Sie brauchen, um zu finden Sie unter Auswirkungen des Kodex auf die einheimischen nach der Funktion exec() gibt.

InformationsquelleAutor Martijn Pieters

Um es zusammenzufassen:

• Es ist kein bug in Python 2 noch in Python 3
• Das unterschiedliche Verhalten von exec stammt aus exec wird eine Anweisung in Python 2, und es wurde eine Funktion in Python 3.

Bitte beachten Sie:

Ich nicht sagen, nichts neues hier. Dieses ist nur eine Montage von der Wahrheit
draußen in allen anderen Antworten und Kommentare.
Alles was ich hier versuche, ist, Licht zu bringen, um einige der obskuren details.

Der einzige Unterschied zwischen Python 2 und Python 3 ist, dass, ja, exec ist in der Lage, ändern Sie den lokalen Gültigkeitsbereich der umgebenden Funktion, die in Python 2 (denn es ist eine Aussage und kann den Zugriff auf die aktuellen lokalen Bereich) und diese nicht mehr in Python 3 (weil es jetzt eine Funktion, so läuft in seinem eigenen lokalen Bereich).

Die Reizung, aber hat nichts zu tun mit der exec Anweisung, es nur rührt von einem speziellen Verhalten detail:

locals() gibt etwas, das ich nennen will "eine Umfang-Weise veränderlich singleton, die nach dem Aufruf locals() immer nur Verweise, die alle Variablen im lokalen Bereich".

Bitte beachten Sie, dass das Verhalten von locals() änderte sich nicht zwischen Python 2 und 3. So, dieses Verhalten zusammen mit ändern, wie exec Werke sieht wie unberechenbar, aber nicht, wie Sie es nur macht, einige Details, die immer da war.

Was bedeutet "ein Umfang-Weise veränderlich singleton Referenzen auf Variablen im lokalen Bereich"?

• Es ist ein scope-wise singleton, wie unabhängig davon, wie oft Sie anrufen locals() im gleichen Umfang, ist das zurückgegebene Objekt ist immer das gleiche.
  • Daher die Beobachtung, dass id(d) == id(locals()), weil d und locals() beziehen sich auf das gleiche Objekt, die gleiche singleton, so kann es nur einen (in einem anderen Bereich erhalten Sie ein anderes Objekt, aber in den gleichen Bereich, den Sie sehen nur das einzelne).
• Es ist mutable, als es ein normales Objekt, so können Sie es ändern.
  • locals() zwingt alle Einträge im Objekt der Referenz der Variablen im lokalen Bereich wieder.
  • Wenn Sie eine änderung in das Objekt (über d), dadurch verändert sich das Objekt, es ist ein normaler veränderliches Objekt.

• Diese änderungen der singleton nicht ausbreiten zurück in den lokalen Bereich, da alle Eingaben in das Objekt references to the variables in the local scope. Also, wenn Sie ändern die Einträge, diese änderungen der singleton-Objekt, und nicht den Inhalt, wo "die Verweise darauf hingewiesen, bevor Sie ändern Sie den Verweis" (daher ändern Sie nicht die lokalen Variablen).

  • In Python Zeichenketten und Zahlen sind nicht veränderbar. Das heißt, Sie weisen etwas auf einen Eintrag, ändern Sie nicht das Objekt, in dem die Einstiegspunkte, Sie führen ein neues Objekt und eine Referenz zuweisen, die auf den Eintrag. Beispiel:

    a = 1
    d = locals()
    d['a'] = 300
    # d['a']==300
    locals()
    # d['a']==1

  Neben der Optimierung bedeutet dies:

  • Erstellen neues Objekt-Nummer(1) - die etwas andere singleton, BTW.
  • speichern Zeiger auf diese Zahl(1) in LOCALS['a']
    
    (wo LOCALS werden die internen lokalen Bereich)
  • Wenn nicht bereits vorhanden, erstellen Sie SINGLETON Objekt
  • update SINGLETON, so verweisen alle Einträge in LOCALS
  • store Zeiger der SINGLETON in LOCALS['d']
  • Erstellen Anzahl(300), die nicht ein singleton, BTW.
  • speichern Zeiger auf diese Zahl(300) in d['a']
  • daher die SINGLETON ist ebenfalls aktualisiert.
  • aber LOCALS ist nicht aktualisiert,
    also die lokale variable a oder LOCALS['a'] noch ist die Nummer(1)
  • Jetzt locals() erneut aufgerufen wird, die SINGLETON aktualisiert.
  • Als d bezieht sich auf SINGLETON, nicht LOCALS, d änderungen, auch!

Mehr auf dieses überraschende detail, warum 1 ist ein singleton, während 300 ist nicht der Fall, siehe https://stackoverflow.com/a/306353

Aber bitte nicht vergessen: die Zahlen sind unveränderlich, so dass, wenn Sie versuchen, ändern Sie eine Zahl ein anderer Wert, die Sie effektiv erstellen Sie ein anderes Objekt.

Fazit:

Können Sie nicht zurück zu bringen die exec Verhalten von Python 2 zu Python 3 (außer durch änderung des Codes), da es keine Möglichkeit gibt, das zu ändern und den lokalen Variablen, die außerhalb des Programms fließen nicht mehr.

Jedoch können Sie bringen das Verhalten von Python 3 auf Python 2, so dass Sie, heute können Programme schreiben, die die gleiche, unabhängig davon, ob Sie laufen mit Python 3 und Python 2. Dies ist, weil in (neueren) Python 2 können Sie exec mit Funktion wie Argumente als gut (in der Tat, jene ist ein 2 - oder 3-Tupel), ermöglicht die Verwendung der gleichen syntax bei gleicher Semantik, bekannt aus Python 3:

exec "code"

(das funktioniert nur in Python 2) wird zu (für Python 2 und 3):

exec("code", globals(), locals())

Aber Vorsicht, daß "code" kann nicht mehr alter die lokale einschließenden Geltungsbereich diese Weise. Siehe auch https://docs.python.org/2/reference/simple_stmts.html#exec

Einige Letzte Worte:

Die änderung der exec in Python 3 ist gut. Aufgrund der Optimierung.

In Python 2 Sie waren nicht in der Lage zu optimieren, über exec, weil der Staat alle lokalen Variablen, die enthalten unveränderliche Inhalte könnten unvorhersehbar ändern. Dies kann nicht mehr passieren. Nun die üblichen Regeln der Funktionsaufrufe anwenden zu exec() wie alle anderen Funktionen auch.

InformationsquelleAutor Tino