[PYTHON] Ich habe untersucht, wie das Zielfernrohr aussieht

Als ich mir die Implementierung der Schließung ansah, wusste ich nicht, warum sie funktioniert, also habe ich mir angesehen, wie der Umfang aussieht. Ich denke, es ist sehr einfach, aber ich konnte keinen Artikel im Internet finden, der verstehen könnte, wie der Umfang aussieht. Als Ergebnis der tatsächlichen Bewegung fand ich es schwierig zu erklären.

Umfang von der obersten Ebene aus gesehen

Lassen Sie uns den Status globaler und lokaler Variablen mit dem folgenden Code überprüfen.

Bestätigung (1)

from pprint import pprint
print "-----globals----->>>"
pprint(globals())
print "-----locals----->>>"
pprint(locals())

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'pprint': <function pprint at 0x02222770>}
-----locals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'pprint': <function pprint at 0x02222770>}

In diesem Zustand sind die Inhalte, die sowohl für globale als auch für lokale Variablen angezeigt werden, gleich. Was passiert, wenn Sie eine Variable definieren?

Bestätigung (2)

from pprint import pprint
a = 123
pprint(globals())
print "-----globals----->>>"
print "-----locals----->>>"
pprint(locals())

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>}
-----locals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>}

In der Skriptausführungsumgebung der obersten Ebene sind die Ausgabeinhalte von local () und globals () identisch. Die definierten Variablen sind in beiden Ausgängen vorhanden. (*** Globals () und Local () geben die Namen des globalen Bereichs bzw. des lokalen Bereichs aus, und das Folgende wird beschrieben **)

Außerdem ist pprint in der Ausgabe von globals () enthalten. (auch bei Einheimischen ()) Durch Import importierte Module und Funktionen werden in den globalen Bereich aufgenommen. (Diejenigen, auf die auf oberster Ebene direkt verwiesen werden kann, liegen im globalen Bereich.)

Was passiert, wenn Sie eine Funktion definieren und den Bereich innerhalb der Funktion betrachten?

Umfang von der Funktion aus gesehen

##Bestätigung(3)
a = 123
def tes001():
	b = 234
	print "-----globals----->>>"
	pprint(globals())
	print "-----locals----->>>"
	pprint(locals())
tes001()

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02422770>,
 'tes001': <function tes001 at 0x02422BF0>}
-----locals----->>>
{'b': 234}

Die im Funktionsblock definierte Variable b existiert im lokalen Bereich, jedoch nicht im globalen Bereich.

• Der Umfang der Klasse wird sich wahrscheinlich ausbreiten, daher werde ich ihn hier nicht erwähnen.

Definieren wir nun die Variablen, nachdem der Inhalt von local () und globals () im Funktionsblock angezeigt wurde.

Bestätigung (4)

a = 123
def tes001():
	print "-----globals----->>>"
	pprint(globals())
	print "-----locals----->>>"
	pprint(locals())
	b = 234
tes001()

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BF0>}
-----locals----->>>
{}

In diesem Fall befindet sich die Variable b auch nicht im lokalen Bereich. Was passiert, wenn Sie die Ausgabe von local () vor und nach der Variablendefinition platzieren?

Bestätigung (5)

a = 123
def tes001():
	print "-----globals----->>>"
	pprint(globals())
	print "-----locals(1)----->>>"
	pprint(locals())
	b = 234
	print "-----locals(2)----->>>"
	pprint(locals())
tes001()

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BF0>}
-----locals(1)----->>>
{}
-----locals(2)----->>>
{'b': 234}

Dies ist wie erwartet. Es befindet sich nicht in der Ausgabe, bevor die Variable definiert wurde, sondern in der Ausgabe, nachdem sie definiert wurde.

Nest-Funktionen, um den Umfang herauszufinden

Verschachteln Sie als Nächstes die Funktionsdefinitionen und überprüfen Sie den Bereich anhand der inneren Funktion.

Bestätigung (6)

a = 123
def tes001():
	b = 234
	def inner():
		c = 345
		print "-----globals----->>>"
		pprint(globals())
		print "-----locals----->>>"
		pprint(locals())
	inner()
tes001()

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x022226F0>,
 'tes001': <function tes001 at 0x02222BF0>}
-----locals----->>>
{'c': 345}

Es gibt kein b im lokalen Bereich von inner (). Was passiert, wenn Sie in inner () auf b verweisen? Zeigen Sie die Ausgabe von local () vor und nach der Referenzierung an.

Bestätigung (7)

a = 123
def tes001():
	b = 234
	def inner():
		c = 345
		print "-----globals----->>>"
		pprint(globals())
		print "-----locals(1)----->>>"
		pprint(locals())
		print b
		print "-----locals(2)----->>>"
		pprint(locals())
	inner()
tes001()

Ausführungsergebnis

-----globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x022226F0>,
 'tes001': <function tes001 at 0x02222BF0>}
-----locals(1)----->>>
{'b': 234, 'c': 345}
234
-----locals(2)----->>>
{'b': 234, 'c': 345}

Dieses Mal existiert die Variable b auch im lokalen Bereich, bevor auf die Variable b verwiesen wird ( print b). Dies sieht etwas anders aus als "Bestätigung (5)". Das Verhalten unterscheidet sich zwischen Referenz und Zuordnung. Sinnlich

-----locals(1)----->>>
{'c': 345}
234
-----locals(2)----->>>
{'b': 234, 'c': 345}

Ich dachte, es wäre so. Das obige Ergebnis setzt voraus, dass der lokale Bereich der Funktion inner () einen Bereich hat, der die Variable b enthält, bevor der Code ausgeführt wird. Erstens ist die Variable b im lokalen Bereich enthalten, obwohl sie in der Funktion inner () nicht definiert ist. Unter dem Gesichtspunkt der Bewegung wird, wenn die Funktion verschachtelt ist, wenn sich die innere Funktion auf eine Variable bezieht, die nicht definiert und außerhalb definiert ist, wenn sich die innere Funktion darauf bezieht, der Definitionsinhalt der äußeren Funktion kopiert und die innere Funktion kopiert. Stellen Sie den lokalen Bereich von ein. Es scheint, dass diese Bereichseinstellung vor der Codeausführung vorgenommen wird. Es fühlt sich an, als würde der Anfangswert des lokalen Bereichs erstellt, bevor die Funktion ausgeführt wird.

Lassen Sie uns den Bereich untersuchen, wenn die außen definierte Variable mit der Funktion innen geändert wird.

Bestätigung (8)

a = 123
def tes001():
	b = 234
	def inner():
		c = 345
		print "-----inner: globals----->>>"
		pprint(globals())
		print "-----inner: locals(1)----->>>"
		pprint(locals())
		print b
		b = 777
		print "-----inner: locals(2)----->>>"
		pprint(locals())
	inner()
	print "-----outer: locals(3)----->>>"
	pprint(locals())
tes001()

Ausführungsergebnis

-----inner: globals----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes002.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x022226F0>,
 'tes001': <function tes001 at 0x02222BF0>}
-----inner: locals(1)----->>>
{'c': 345}
Traceback (most recent call last):
  File "tes002.py", line 19, in <module>
    tes001()
  File "tes002.py", line 16, in tes001
    inner()
  File "tes002.py", line 12, in inner
    print b
UnboundLocalError: local variable 'b' referenced before assignment

Nach dem Ausführen des obigen Vorgangs wurde ein Fehler angezeigt (Ungebundener lokaler Fehler). Interessanterweise enthält der Inhalt von local (), der zuerst von der Funktion inner () ausgegeben wird, nicht die Variable b. Wenn nur die Referenz ( print b) gemacht wurde, wurde b eingeschlossen. Der einzige Unterschied besteht darin, ob die innere Funktion die auf der äußeren definierten Variablen festlegt. Schließlich scheint der Bereich vor der Ausführung des Codes vorbereitet zu sein. Der Code funktioniert basierend auf diesem vorbereiteten Bereich. Im obigen Beispiel wird die Variable b jedoch nicht in dem zur Laufzeit vorbereiteten lokalen Bereich festgelegt, da die interne Funktion einen Einstellungscode ( b = 777) enthält. In diesem Zustand (Variable b ist nicht im Gültigkeitsbereich) tritt ein Fehler auf, wenn versucht wird, auf Variable b zu verweisen.

Lassen Sie uns die bisher bestätigten Ergebnisse organisieren

Wenn Sie die bisher bestätigten Inhalte organisieren, einschließlich einiger Schlussfolgerungen (Spekulationen),

• In der Ausführungsumgebung der obersten Ebene werden alle definierten Variablen und Funktionen auf den globalen Bereich festgelegt. Variablen werden durch Zuordnung definiert.
• Der gleiche globale Bereich kann sowohl von der obersten Ebene als auch von der Funktion aus gesehen werden. (Wahrscheinlich) --Variationen und Funktionen (interne Funktionen), die in einer Funktion definiert sind, werden im lokalen Bereich dieser Funktion festgelegt. -Wenn Sie in einer Funktion auf eine undefinierte Variable verweisen, suchen Sie vor der Ausführung des Codes nach der in der äußeren Funktion definierten Variablen von der Nähe der Funktion nach außen und nach dem lokalen Bereich der gefundenen Variablen. Einstellen. Die Funktion arbeitet mit diesem lokalen Bereich.
• Beim Zuweisen zu einer Variablen in einer Funktion wird die Variable jedoch in der Funktion definiert, und die Variable wird zum Zeitpunkt der Ausführung nicht im lokalen Bereich festgelegt. Wenn Sie in diesem Zustand versuchen, vor der Zuweisung auf eine Variable zu verweisen, tritt ein Fehler (UnboundLocalError) auf.

Untersuchen Sie, wie der Bereich aussieht, wenn auf eine globale Variable verwiesen und in einer Funktion festgelegt wird

Als nächstes untersuchen wir, wie der Bereich aussieht, wenn auf die globale Variable verwiesen und in der Funktion festgelegt wird.

Bestätigung (8)

a = 123
def tes001():
	print a
	print "-----tes001: globals(1)----->>>"
	pprint(globals())
	print "-----tes001: locals(1)----->>>"
	pprint(locals())
	a = 345
	print "-----tes001: globals(2)----->>>"
	pprint(globals())
	print "-----tes001: locals(2)----->>>"
	pprint(locals())
tes001()
print "-----top: globals(3)----->>>"
pprint(globals())
print "-----top: locals(3)----->>>"
pprint(locals())

Ausführungsergebnis

Traceback (most recent call last):
  File "tes003.py", line 15, in <module>
    tes001()
  File "tes003.py", line 5, in tes001
    print a
UnboundLocalError: local variable 'a' referenced before assignment

In diesem Fall das Gleiche wie Bestätigung (7). UnboundLocalError. Das gleiche Verhalten, wenn der globale Bereich und der lokale Bereich gemischt werden. In der Funktion tes001 () sollte es funktionieren, die Variable a zuzuweisen und dann darauf zu verweisen.

Bestätigung (9)

a = 123
def tes001():
	print "-----tes001: globals(1)----->>>"
	pprint(globals())
	print "-----tes001: locals(1)----->>>"
	pprint(locals())
	a = 345
	print a
	print "-----tes001: globals(2)----->>>"
	pprint(globals())
	print "-----tes001: locals(2)----->>>"
	pprint(locals())
tes001()
print "-----top: globals(3)----->>>"
pprint(globals())
print "-----top: locals(3)----->>>"
pprint(locals())

Ausführungsergebnis

-----tes001: globals(1)----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes003.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BB0>}
-----tes001: locals(1)----->>>
{}
345
-----tes001: globals(2)----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes003.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BB0>}
-----tes001: locals(2)----->>>
{'a': 345}
-----top: globals(3)----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes003.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BB0>}
-----top: locals(3)----->>>
{'__builtins__': <module '__builtin__' (built-in)>,
 '__doc__': None,
 '__file__': 'tes003.py',
 '__name__': '__main__',
 '__package__': None,
 'a': 123,
 'pprint': <function pprint at 0x02222770>,
 'tes001': <function tes001 at 0x02222BB0>}

Das hat gut funktioniert. In der Ausgabe von tes001: globals (2) ist a 123 und in der Ausgabe von tes001: local (2) 345. In tes001 () wird die lokale Variable a neu geschrieben, sodass der Wert von a bei der Rückkehr zur obersten Ebene der Wert (123) vor dem Funktionsaufruf bleibt. Ich habe die Theorie irgendwie verstanden, aber sie fühlt sich etwas seltsam an. Entfernen Sie die print-Anweisung und versuchen Sie, den Code anzuordnen, wenn er funktioniert und wenn er nicht funktioniert.

Organisieren Sie Code für Funktionen, die auf Variablen zugreifen, die als globale Variablen definiert sind

Wenn es funktioniert (1)

a = 123
def tes001():
	print a
tes001()

Wenn es funktioniert (2)

a = 123
def tes001():
	a = 345
	print a
tes001()

Wenn es nicht funktioniert

a = 123
def tes001():
	print a			#UnboundLocalError
	a = 345
tes001()

Ich habe verschiedene Bewegungen ausgeführt und Gründe für die Operationsergebnisse angegeben, aber wenn ich mir das oben Gesagte anschaue, ist es immer noch schwer zu verstehen. Ich würde gerne etwas mehr untersuchen, aber es wird länger, also höre ich hier auf. Ich denke, ich kann die Umsetzung von Schließungen erklären.