Python Global-Schlüsselwort

Stellen Sie sicher, dass Sie die Inhalte dieses Artikels gelesen haben, bevor Sie fortfahren.Python-globale, lokale und nicht lokale VariablenEinige Grundkenntnisse.

Einführung in das globale Schlüsselwort

Das Schlüsselwort global in Python ermöglicht es Ihnen, Variablen außerhalb des aktuellen Bereichs zu ändern. Es wird verwendet, um globale Variablen zu erstellen und diese in einem lokalen Kontext zu ändern.

Regeln für das globale Schlüsselwort

Die grundlegenden Regeln für das Schlüsselwort global in Python sind:

• Wenn wir Variablen im Inneren der Funktion erstellen, ist sie standardmäßig lokal.

• Wenn wir Variablen außerhalb der Funktion definieren, ist sie standardmäßig global. Sie müssen das Schlüsselwort global nicht verwenden.

• Wir verwenden das Schlüsselwort global, um globale Variablen im Inneren der Funktion zu lesen und zu schreiben.

• Die Verwendung des Schlüsselworts global außerhalb der Funktion ist ungültig

Verwendung des globalen Schlüsselworts (Beispiel)

Lassen Sie uns ein Beispiel nennen.

Beispiel1：Globale Variablen aus dem Inneren der Funktion lesen

c =　1　# globale Variable
def add():
　　　　print(c)
add()

Wenn wir das obige Programm ausführen, wird die Ausgabe sein:

1

Aber in einigen Fällen müssen wir globale Variablen aus dem Inneren der Funktion ändern.

Beispiel2：Globale Variablen aus dem Inneren der Funktion ändern

c =　1　# globale Variable
　　　　
def add():
　　　　c = c　+　2　# erhöhen c um　2
　　　　print(c)
add()

Wenn wir das obige Programm ausführen, wird die Ausgabe eine Fehlermeldung anzeigen:

UnboundLocalError: local variable 'c' referenced before assignment

Dies liegt daran, dass wir nur auf globale Variablen zugreifen können, sie aber nicht aus dem Inneren der Funktion ändern können.

Die Lösung ist, das Schlüsselwort global zu verwenden.

Beispiel3：Verwenden Sie global, um globale Variablen aus dem Inneren der Funktion zu ändern

c = 0 # globale Variable
def add():
　　　　global c
　　　　c = c　+　2　# erhöhen um　2
　　　　print("Inside add():", c)
add()
print("In main:", c)

Wenn wir das obige Programm ausführen, wird die Ausgabe sein:

Innerhalb von add():　2
In main:　2

Im obigen Programm definieren wir c als globales Schlüsselwort innerhalb der Funktion add().
Dann erhöhen wir die Variable c1d.h. c = c + 2. Nachdem wir die Funktion add() aufgerufen haben, drucken wir schließlich die globale Variable c.
Wie wir sehen können, hat sich auch die globale Variable außerhalb der Funktion geändert c = 2.

Globale Variablen zwischen Python-Modulen

In Python erstellen wir ein Modul config.py, um globale Variablen zu speichern und Informationen zwischen Python-Modulen desselben Programms zu teilen.

So teilen wir globale Variablen zwischen Python-Modulen.

Beispiel4： zwischen Python-Modulen globale Variablen teilen

Erstellen Sie eine Datei config.py, um globale Variablen zu speichern

a = 0
b = "empty"

Erstellen Sie eine Datei update.py, um die globale Variable zu ändern

import config
config.a =　10
config.b = "alphabet"

Erstellen Sie eine Datei main.py, um die Änderung der Werte zu testen

import config
import update
print(config.a)
print(config.b)

Wenn wir die Datei main.py ausführen, wird die Ausgabe sein

10
alphabet

In dem obigen Text haben wir drei Dateien erstellt: config.py, update.py und main.py.

Der Modul config.py speichertaundbglobale Variablen. In der Datei update.py importieren wir das Modul config.py und ändernaundbWert. Ebenso importieren wir in der Datei main.py gleichzeitig die Module config.py und update.py. Schließlich drucken und testen wir den Wert der globalen Variablen, ob sie geändert wurden oder nicht.

Globale Variablen in eingebetteten Funktionen

Dies ist die Methode, um globale Variablen in eingebetteten Funktionen zu verwenden.

Beispiel5: Verwenden von globalen Variablen in eingebetteten Funktionen

def foo():
　　　　x =　20
　　　　def bar():
　　　　　　　　global x
　　　　　　　　x =　25
　　　　
　　　　print("Vor dem Aufruf von bar:", x)
　　　　print("Direkter Aufruf von bar")
　　　　bar()
　　　　print("Nach dem Aufruf von bar:", x)
foo()
print("x im Hauptbereich: ", x)

Die Ausgabe ist:

Vor dem Aufruf von bar:　　20
Direkter Aufruf von bar
Nach dem Aufruf von bar():　　20
x im Hauptbereich:　　25

Im obigen Programm haben wir im eingebetteten Funktion bar() eine globale Variable deklariert. In der Funktion foo() hat x keinen Einfluss auf das globale Schlüsselwort.
Vor und nach dem Aufruf von bar() akzeptiert die Variable x den Wert des lokalen Variablenbereichs, d.h. x =20. Außerhalb der Funktion foo() wird die Variable x den Wert aus der Funktion bar() annehmen, d.h. x =25Das liegt daran, dass wir im Bereich der Funktion bar() mit dem globalen Schlüsselwort eine globale Variable in x erstellt haben.
Wenn wir in der Funktion bar() Änderungen vorgenommen haben, werden diese Änderungen außerhalb des lokalen Bereichs sichtbar, nämlich in foo().