Python3 Namensraum und Gültigkeitsbereich

Namespace

Schauen wir uns zunächst einen Abschnitt aus der offiziellen Dokumentation an:

Ein Namensraum ist eine Zuordnung von Namen zu Objekten. Die meisten Namensräume sind derzeit als Python-Dictionaries implementiert.

Ein Namensraum ist eine Zuordnung von Namen zu Objekten. Die meisten Namensräume sind derzeit als Python-Dictionaries implementiert.

Namensräume bieten eine Möglichkeit, Namenskonflikte in Projekten zu vermeiden. Jeder Namensraum ist unabhängig und hat keine Beziehung zu anderen, daher kann ein einzelner Namensraum keine doppelten Namen haben, aber verschiedene Namensräume können denselben Namen haben, ohne dass dies Auswirkungen hat.

Nehmen wir ein Beispiel aus einem Computersystem: Ein Ordner (Verzeichnis) kann mehrere Ordner enthalten, und in jedem Ordner dürfen Dateien nicht denselben Namen haben, aber Dateien in verschiedenen Ordnern können denselben Namen haben.

Es gibt im Allgemeinen drei Arten von Namensräumen:

  • Eingebaute Namen (built-in names), in die Python-Sprache integrierte Namen, wie Funktionsnamen abs, char und Ausnahmenamen BaseException, Exception usw.
  • Globale Namen (global names), in einem Modul definierte Namen, die die Variablen des Moduls aufzeichnen, einschließlich Funktionen, Klassen, anderer importierter Module sowie Variablen und Konstanten auf Modulebene.
  • Lokale Namen (local names), in einer Funktion definierte Namen, die die Variablen der Funktion aufzeichnen, einschließlich Funktionsparameter und lokal definierter Variablen. (In einer Klasse definierte sind ebenfalls enthalten.)

Reihenfolge der Namensraum-Suche:

Angenommen, wir möchten die Variable example verwenden, dann ist Pythons Suchreihenfolge:Lokaler Namensraum -> Globaler Namensraum -> Eingebauter Namensraum。

Wenn die Variable example nicht gefunden wird, wird die Suche aufgegeben und eine NameError-Ausnahme ausgelöst:

NameError: name 'example' is not defined.

Der Lebenszyklus eines Namensraums:

Der Lebenszyklus eines Namensraums hängt vom Gültigkeitsbereich des Objekts ab. Wenn das Objekt die Ausführung beendet hat, endet der Lebenszyklus dieses Namensraums.

Daher können wir nicht von einem äußeren Namensraum aus auf Objekte in einem inneren Namensraum zugreifen.

Beispiel

# var1 ist ein globaler Name
var1 = 5
def some_func():
 
    # var2 ist ein lokaler Name
    var2 = 6
    def some_inner_func():
 
        # var3 ist ein verschachtelter lokaler Name
        var3 = 7

Wie in der folgenden Abbildung gezeigt, kann derselbe Objektname in mehreren Namensräumen existieren.

Geltungsbereich

Ein Geltungsbereich ist ein textueller Bereich eines Python-Programms, in dem ein Namensraum direkt zugänglich ist. "Direkt zugänglich" bedeutet hier, dass eine unqualifizierte Referenz auf einen Namen versucht, den Namen im Namensraum zu finden.

Ein Geltungsbereich ist der textuelle Bereich eines Python-Programms, in dem ein Namensraum direkt zugänglich ist.

In einem Python-Programm greift ein direkter Zugriff auf eine Variable auf alle Geltungsbereiche von innen nach außen zu, bis sie gefunden wird; andernfalls wird ein Fehler wegen Nichtdefiniertheit gemeldet.

In Python kann nicht von jeder beliebigen Stelle aus auf die Variablen eines Programms zugegriffen werden; die Zugriffsberechtigungen hängen davon ab, wo die Variable zugewiesen wird.

Der Geltungsbereich einer Variablen bestimmt, welcher Teil des Programms auf einen bestimmten Variablennamen zugreifen kann.

Python hat insgesamt 4 Geltungsbereiche, nämlich:

Es gibt vier Geltungsbereiche:

  • L（Local）: Die innerste Ebene, die lokale Variablen enthält, wie innerhalb einer Funktion/Methode.
  • E（Enclosing）: Enthält Variablen, die nicht lokal (non-local) und auch nicht global (non-global) sind. Zum Beispiel bei zwei verschachtelten Funktionen: Wenn eine Funktion (oder Klasse) A eine andere Funktion B enthält, dann ist für Namen in B der Gültigkeitsbereich in A nonlocal.
  • G（Global）: Die äußerste Ebene des aktuellen Skripts, wie die globalen Variablen des aktuellen Moduls.
  • B（Built-in）: Enthält integrierte Variablen/Schlüsselwörter usw., wird zuletzt durchsucht.

LEGB-Regel (Local, Enclosing, Global, Built-in): Die Reihenfolge, in der Python Variablen nachschlägt, ist:L –> E –> G –> B。

  1. Local: Der lokale Gültigkeitsbereich der aktuellen Funktion.
  2. Enclosing: Der Gültigkeitsbereich der äußeren Funktion, die die aktuelle Funktion enthält (falls verschachtelte Funktionen vorhanden sind).
  3. Global: Der globale Gültigkeitsbereich des aktuellen Moduls.
  4. Built-in: Pythons integrierter Gültigkeitsbereich.

Wenn es lokal nicht gefunden wird, sucht es im umschließenden lokalen Gültigkeitsbereich (z. B. Closures); wenn es immer noch nicht gefunden wird, sucht es im globalen Gültigkeitsbereich und dann im integrierten Gültigkeitsbereich.

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Der integrierte Gültigkeitsbereich wird durch ein Standardmodul namens builtin implementiert, aber der Variablenname selbst wird nicht in den integrierten Gültigkeitsbereich gelegt, daher müssen Sie diese Datei importieren, um sie zu verwenden. In Python 3.0 können Sie den folgenden Code verwenden, um genau zu sehen, welche Variablen vordefiniert sind:

>>> import builtins
>>> dir(builtins)

In Python führen nur Module, Klassen und Funktionen (def, lambda) neue Gültigkeitsbereiche ein. Andere Codeblöcke (wie if/elif/else, try/except, for/while usw.) führen keine neuen Gültigkeitsbereiche ein. Das heißt, auf Variablen, die innerhalb dieser Anweisungen definiert werden, kann auch von außen zugegriffen werden, wie im folgenden Code:

>>> if True:
...  msg = 'I am from Example'
... 
>>> msg
'I am from Example'
>>>

Im Beispiel wird die Variable msg in einem if-Anweisungsblock definiert, aber auf sie kann trotzdem von außen zugegriffen werden.

Wenn msg innerhalb einer Funktion definiert wird, dann ist sie eine lokale Variable, auf die nicht von außen zugegriffen werden kann:

>>> def test():
...     msg_inner = 'I am from Example'
... 
>>> msg_inner
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>

Aus der Fehlermeldung geht hervor, dass msg_inner nicht definiert ist und nicht verwendet werden kann, weil sie eine lokale Variable ist und nur innerhalb der Funktion verwendet werden kann.

Globale und lokale Variablen

Variablen, die innerhalb einer Funktion definiert werden, haben einen lokalen Gültigkeitsbereich, und diejenigen, die außerhalb einer Funktion definiert werden, haben einen globalen Gültigkeitsbereich.

Auf lokale Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie deklariert sind, während auf globale Variablen im gesamten Programm zugegriffen werden kann.

Variablen, die innerhalb einer Funktion deklariert werden, sind nur im Gültigkeitsbereich innerhalb der Funktion gültig. Wenn die Funktion aufgerufen wird, werden diese internen Variablen zum internen Gültigkeitsbereich der Funktion hinzugefügt und beeinflussen keine gleichnamigen Variablen außerhalb der Funktion, wie im folgenden Beispiel:

Beispiel (Python 3.0+)

#!/usr/bin/python3 total = 0 # Dies ist eine globale Variable # Funktionsbeschreibung def sum( arg1, arg2 ): # Gibt die Summe zweier Parameter zurück. total = arg1 + arg2 # total ist hier eine lokale Variable. print ("Innerhalb der Funktion ist sie eine lokale Variable:", total) return total # Summenfunktion aufrufen sum( 10, 20 ) print ("Außerhalb der Funktion ist sie eine globale Variable:", total)

Die Ausgabe des obigen Beispiels ist:

函数内是局部变量 :  30
函数外是全局变量 :  0

1. Globale Variablen: Auf Variablen, die außerhalb einer Funktion definiert werden, kann in der gesamten Datei zugegriffen werden. Variablen, die außerhalb einer Funktion definiert werden, sind für alle Funktionen sichtbar, es sei denn, innerhalb der Funktion wird eine lokale Variable mit demselben Namen definiert.

Beispiel

x = 10  # Globale Variable

def my_function():
    print(x)  # Kann auf globale Variable x zugreifen

my_function()  # Gibt 10 aus

2. Lokale Variablen: Variablen, die innerhalb einer Funktion definiert werden, sind nur innerhalb der Funktion gültig und von außen nicht zugänglich. Lokale Variablen haben eine höhere Priorität als globale Variablen. Wenn also eine lokale Variable und eine globale Variable denselben Namen haben, wird innerhalb der Funktion die lokale Variable verwendet.

Beispiel

def my_function():
    x = 5  # Lokale Variable
    print(x)  # Zugriff auf lokale Variable x

my_function()  # Gibt 5 aus
print(x)  # Fehler: NameError: name 'x' is not defined

Die Schlüsselwörter global und nonlocal

Wenn ein innerer Gültigkeitsbereich eine Variable in einem äußeren Gültigkeitsbereich ändern möchte, sind die Schlüsselwörter global und nonlocal erforderlich.

Das folgende Beispiel ändert die globale Variable num:

Beispiel (Python 3.0+)

#!/usr/bin/python3 num = 1 def fun1(): global num # Muss mit dem Schlüsselwort global deklariert werden print(num) num = 123 print(num) fun1() print(num)

Die Ausgabe des obigen Beispiels ist:

1
123
123

Wenn Sie eine Variable in einem verschachtelten Bereich (umgebenden Bereich, den äußeren nicht-globalen Bereich) ändern möchten, benötigen Sie das Schlüsselwort nonlocal, wie im folgenden Beispiel:

Beispiel (Python 3.0+)

#!/usr/bin/python3 def outer(): num = 10 def inner(): nonlocal num # Mit dem Schlüsselwort nonlocal deklarieren num = 100 print(num) inner() print(num) outer()

Die Ausgabe des obigen Beispiels ist:

100
100

Es gibt auch einen Sonderfall. Angenommen, der folgende Code wird ausgeführt:

Beispiel (Python 3.0+)

#!/usr/bin/python3 a = 10 def test(): a = a + 1 print(a) test()

Wenn das obige Programm ausgeführt wird, lautet die Fehlermeldung wie folgt:

Traceback (most recent call last):
  File "test.py", line 7, in <module>
    test()
  File "test.py", line 5, in test
    a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

Die Fehlermeldung ist ein Referenzfehler im lokalen Gültigkeitsbereich, weil a in der Funktion test die lokale Variable verwendet, die nicht definiert ist und nicht geändert werden kann.

Ändern Sie a zu einer globalen Variablen:

Beispiel

#!/usr/bin/python3 a = 10 def test(): global a a = a + 1 print(a) test()

Die Ausgabe der Ausführung ist:

11

Es kann auch über Funktionsparameter übergeben werden:

Beispiel (Python 3.0+)

#!/usr/bin/python3 a = 10 def test(a): a = a + 1 print(a) test(a)

Die Ausgabe der Ausführung ist:

11

Zusammenfassung

  • Globale VariablenAußerhalb einer Funktion definiert, sind sie in der gesamten Datei zugänglich.
  • Lokale VariablenInnerhalb einer Funktion definiert, sind sie nur innerhalb der Funktion zugänglich.
  • Verwenden SieglobalSie können globale Variablen innerhalb einer Funktion ändern.
  • Verwenden SienonlocalSie können die Variablen der äußeren Funktion innerhalb verschachtelter Funktionen ändern.
Weitere Erweiterungen