Globales Python-Schlüsselwort

In diesem Artikel erfahren Sie mehr über das globale Schlüsselwort, die globale Variable und wann Sie globale Schlüsselwörter verwenden sollten.

Bevor Sie diesen Artikel lesen, vergewissern Sie sich, dass Sie einige Grundlagen zu globalen, lokalen und nicht lokalen Python-Variablen haben.

Was ist das globale Schlüsselwort

In Python global Mit dem Schlüsselwort können Sie die Variable außerhalb des aktuellen Gültigkeitsbereichs ändern. Es wird verwendet, um eine globale Variable zu erstellen und Änderungen an der Variablen in einem lokalen Kontext vorzunehmen.

Regeln des globalen Keywords

Die Grundregeln für global Schlüsselwörter in Python sind:

Wenn wir eine Variable innerhalb einer Funktion erstellen, ist sie standardmäßig lokal.
Wenn wir eine Variable außerhalb einer Funktion definieren, ist sie standardmäßig global. Sie müssen global nicht verwenden Schlüsselwort.
Wir verwenden global Schlüsselwort zum Lesen und Schreiben einer globalen Variablen innerhalb einer Funktion.
Verwendung von global Schlüsselwort außerhalb einer Funktion hat keine Auswirkung.

Verwendung des globalen Keywords

Nehmen wir ein Beispiel.

Beispiel 1:Zugriff auf globale Variable innerhalb einer Funktion

c = 1 # global variable

def add():
    print(c)

add()

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

Es kann jedoch vorkommen, dass wir einige Szenarien haben, in denen wir die globale Variable innerhalb einer Funktion ändern müssen.

Beispiel 2:Globale Variable innerhalb der Funktion ändern

c = 1 # global variable
    
def add():
    c = c + 2 # increment c by 2
    print(c)

add()

Wenn wir das obige Programm ausführen, zeigt die Ausgabe einen Fehler:

UnboundLocalError: local variable 'c' referenced before assignment

Dies liegt daran, dass wir nur auf die globale Variable zugreifen, sie aber nicht innerhalb der Funktion ändern können.

Die Lösung hierfür ist die Verwendung des global Schlüsselwort.

Beispiel 3:Ändern einer globalen Variablen innerhalb einer Funktion mit global

c = 0 # global variable

def add():
    global c
    c = c + 2 # increment by 2
    print("Inside add():", c)

add()
print("In main:", c)

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

Inside add(): 2
In main: 2

Im obigen Programm definieren wir c als globales Schlüsselwort innerhalb von add() Funktion.

Dann erhöhen wir die Variable c um 2 , also c = c + 2 . Danach rufen wir den add() auf Funktion. Schließlich geben wir die globale Variable c aus .

Wie wir sehen können, hat sich auch die globale Variable außerhalb der Funktion geändert, c = 2 .

Globale Variablen über Python-Module hinweg

In Python erstellen wir ein einzelnes Modul config.py um globale Variablen zu halten und Informationen über Python-Module innerhalb desselben Programms auszutauschen.

So können wir globale Variablen über die Python-Module hinweg teilen.

Beispiel 4:Eine globale Variable über Python-Module hinweg teilen

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

a = 0
b = "empty"

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

import config

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

Erstellen Sie eine main.py Datei, um Wertänderungen zu testen

import config
import update

print(config.a)
print(config.b)

Wenn wir main.py ausführen Datei ist die Ausgabe

10
alphabet

Oben haben wir drei Dateien erstellt:config.py , update.py , und main.py .

Das Modul config.py speichert globale Variablen von a und b . Im update.py Datei importieren wir den config.py Modul und ändern Sie die Werte von a und b . Ebenso im main.py Datei importieren wir beide config.py und update.py Modul. Schließlich drucken und testen wir die Werte globaler Variablen, ob sie geändert wurden oder nicht.

Global in verschachtelten Funktionen

So können Sie eine globale Variable in einer verschachtelten Funktion verwenden.

Beispiel 5:Verwenden einer globalen Variablen in einer verschachtelten Funktion

def foo():
    x = 20

    def bar():
        global x
        x = 25
    
    print("Before calling bar: ", x)
    print("Calling bar now")
    bar()
    print("After calling bar: ", x)

foo()
print("x in main: ", x)

Die Ausgabe ist :

Before calling bar: 20
Calling bar now
After calling bar: 20
x in main: 25

Im obigen Programm haben wir eine globale Variable innerhalb der verschachtelten Funktion bar() deklariert . Innerhalb von foo() Funktion, x hat keine Auswirkung auf das globale Schlüsselwort.

Vor und nach dem Aufruf von bar() , die Variable x nimmt den Wert der lokalen Variablen, z. B. x = 20 . Außerhalb von foo() Funktion, die Variable x nimmt den in bar() definierten Wert an Funktion, also x = 25 . Das liegt daran, dass wir global verwendet haben Schlüsselwort in x um eine globale Variable innerhalb von bar() zu erstellen Funktion (lokaler Geltungsbereich).

Wenn wir Änderungen innerhalb des bar() vornehmen Funktion erscheinen die Änderungen außerhalb des lokalen Bereichs, d. h. foo() .

Python Globale, lokale und nicht lokale Variablen Python-Module

Python