Frage Globale Variablen in einer Funktion verwenden


Wie kann ich eine globale Variable in einer Funktion erstellen oder verwenden?

Wenn ich eine globale Variable in einer Funktion erstelle, wie kann ich diese globale Variable in einer anderen Funktion verwenden? Muss ich die globale Variable in einer lokalen Variablen der Funktion speichern, die ihren Zugriff benötigt?


2466
2018-01-08 05:45


Ursprung


Antworten:


Sie können eine globale Variable in anderen Funktionen verwenden, indem Sie sie als deklarieren global in jeder Funktion, die ihm zuweist:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

Ich stelle mir den Grund dafür vor, dass Python, da globale Variablen so gefährlich sind, sicherstellen möchte, dass du wirklich weißt, dass du damit spielst, indem du explizit die global Stichwort.

Siehe andere Antworten, wenn Sie eine globale Variable für mehrere Module freigeben möchten.


3497
2018-01-08 08:39



Wenn ich Ihre Situation richtig verstehe, sehen Sie, wie Python lokale (Funktions-) und globale (Modul-) Namespaces behandelt.

Angenommen, Sie haben ein Modul wie dieses:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Sie können erwarten, dass dies 42 druckt, aber stattdessen druckt es 5. Wie bereits erwähnt, wenn Sie ein 'hinzufügenglobal"Erklärung zu func1(), dann func2() wird 42 drucken.

def func1():
    global myGlobal
    myGlobal = 42

Was hier vor sich geht ist, dass Python davon ausgeht, dass jeder Name das ist Zugewiesen an, irgendwo innerhalb einer Funktion, ist lokal für diese Funktion, sofern nicht explizit anders angegeben. Wenn es nur ist lesen von einem Namen, und der Name existiert nicht lokal, wird es versuchen, den Namen in irgendwelchen enthaltenden Bereichen nachzuschlagen (z. B. den globalen Gültigkeitsbereich des Moduls).

Wenn Sie dem Namen 42 zuweisen myGlobalDaher erstellt Python eine lokale Variable, die die globale Variable mit demselben Namen schattiert. Das lokale geht außer Reichweite und ist Müll gesammelt wann func1() kehrt zurück; inzwischen, func2() kann nie etwas anderes als den (unveränderten) globalen Namen sehen. Beachten Sie, dass diese Namespace-Entscheidung zur Kompilierungszeit und nicht zur Laufzeit erfolgt - wenn Sie den Wert von myGlobal Innerhalb func1() Bevor Sie es zuweisen, erhalten Sie ein UnboundLocalError, weil Python bereits entschieden hat, dass es sich um eine lokale Variable handeln muss, aber noch kein Wert damit verbunden ist. Aber mit dem 'globalIn diesem Fall sagst du Python, dass es sich an anderer Stelle nach dem Namen umsehen soll, anstatt ihm lokal zuzuweisen.

(Ich glaube, dass dieses Verhalten hauptsächlich durch eine Optimierung lokaler Namespaces ausgelöst wurde - ohne dieses Verhalten müsste Pythons VM jedes Mal, wenn innerhalb einer Funktion ein neuer Name zugewiesen wird, mindestens drei Namenssuchen durchführen (um sicherzustellen, dass der Name nicht vergeben wurde). t bereits auf Modul / Builtin-Ebene vorhanden, was eine sehr häufige Operation erheblich verlangsamen würde.)


660
2018-01-08 09:19



Vielleicht möchten Sie den Begriff von erkunden Namespaces. In Python, der Modul ist der natürliche Ort für global Daten:

Jedes Modul hat seine eigene private Symboltabelle, die von allen im Modul definierten Funktionen als globale Symboltabelle verwendet wird. Daher kann der Autor eines Moduls globale Variablen in dem Modul verwenden, ohne sich um zufällige Zusammenstöße mit den globalen Variablen eines Benutzers kümmern zu müssen. Auf der anderen Seite, wenn Sie wissen, was Sie tun, können Sie die globalen Variablen eines Moduls mit der gleichen Notation berühren, die verwendet wird, um auf seine Funktionen zu verweisen, modname.itemname.

Eine spezifische Verwendung von Global-in-a-Modul wird hier beschrieben - how-do-i-share-globale-Variablen-über-Moduleund der Vollständigkeit halber werden hier die Inhalte geteilt:

Der kanonische Weg, Informationen über Module innerhalb eines einzelnen Programms auszutauschen, besteht darin, ein spezielles Konfigurationsmodul (oft als config oder cfg bezeichnet) zu erstellen. Importieren Sie das Konfigurationsmodul einfach in alle Module Ihrer Anwendung. Das Modul wird dann als globaler Name verfügbar. Da für jedes Modul nur eine Instanz vorhanden ist, werden Änderungen am Modulobjekt überall berücksichtigt. Beispielsweise:

Datei: config.py

x = 0   # Default value of the 'x' configuration setting

Datei: mod.py

import config
config.x = 1

Datei: main.py

import config
import mod
print config.x

175
2018-01-08 05:59



Python verwendet eine einfache Heuristik, um zu entscheiden, in welchen Bereich es eine Variable zwischen lokal und global laden soll. Wenn ein Variablenname auf der linken Seite einer Zuweisung erscheint, aber nicht als global deklariert wird, wird angenommen, dass er lokal ist. Wenn es nicht auf der linken Seite einer Zuweisung erscheint, wird angenommen, dass es global ist.

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

Siehe wie baz, das auf der linken Seite einer Aufgabe in erscheint foo(), ist das einzige LOAD_FAST Variable.


75
2017-07-12 12:35



Wenn Sie in einer Funktion auf eine globale Variable verweisen möchten, können Sie die verwenden global Schlüsselwort, um zu deklarieren, welche Variablen global sind. Sie müssen es nicht in allen Fällen verwenden (wie jemand hier fälschlicherweise behauptet) - wenn der in einem Ausdruck referenzierte Name nicht in lokalem Bereich oder Bereichen in den Funktionen gefunden wird, in denen diese Funktion definiert ist, wird er global gesucht Variablen.

Wenn Sie jedoch eine neue Variable zuweisen, die in der Funktion nicht als global deklariert ist, wird sie implizit als lokal deklariert und kann jede vorhandene globale Variable mit demselben Namen überschatten.

Außerdem sind globale Variablen nützlich, im Gegensatz zu einigen OOP-Fanatikern, die etwas anderes behaupten - besonders für kleinere Skripte, bei denen OOP übertrieben ist.


47
2018-01-08 09:03



Zusätzlich zu bereits vorhandenen Antworten und um dies noch verwirrender zu machen:

In Python sind Variablen, die nur innerhalb einer Funktion referenziert werden    implizit global. Wenn einer Variablen irgendwo ein neuer Wert zugewiesen wird   innerhalb des Körpers der Funktion wird angenommen, dass es ein a ist lokal. Wenn eine Variable   wird innerhalb der Funktion immer ein neuer Wert zugewiesen, die Variable ist   implizit lokal, und Sie müssen es explizit als 'global' deklarieren.

Obwohl es zunächst ein wenig überraschend ist, erklärt ein Moment der Überlegung   Dies. Auf der einen Seite bietet die Anforderung global für zugewiesene Variablen a   Bar gegen unbeabsichtigte Nebenwirkungen. Auf der anderen Seite, wenn global war   erforderlich für alle globalen Referenzen, würden Sie global alle verwenden   Zeit. Sie müssten jeden Verweis auf eine integrierte Komponente als global deklarieren   Funktion oder zu einer Komponente eines importierten Moduls. Dieses Durcheinander würde   die Nützlichkeit der globalen Deklaration zur Identifizierung zu vereiteln   Nebenwirkungen.

Quelle: Welche Regeln gelten für lokale und globale Variablen in Python?.


36
2017-07-04 10:23



Wenn ich eine globale Variable in einer Funktion erstelle, wie kann ich diese Variable in einer anderen Funktion verwenden?

Wir können eine globale mit der folgenden Funktion erstellen:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

Das Schreiben einer Funktion führt ihren Code nicht wirklich aus. Also rufen wir an create_global_variable Funktion:

>>> create_global_variable()

Globals ohne Modifikation verwenden

Sie können es einfach verwenden, solange Sie nicht erwarten, das Objekt zu ändern, auf das es zeigt:

Beispielsweise,

def use_global_variable():
    return global_variable + '!!!'

und jetzt können wir die globale Variable verwenden:

>>> use_global_variable()
'Foo!!!'

Änderung der globalen Variablen innerhalb einer Funktion

Um die globale Variable auf ein anderes Objekt zu verweisen, müssen Sie das globale Schlüsselwort erneut verwenden:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

Beachten Sie, dass nach dem Schreiben dieser Funktion der Code, der sie tatsächlich geändert hat, immer noch nicht ausgeführt wurde:

>>> use_global_variable()
'Foo!!!'

Also nach dem Aufruf der Funktion:

>>> change_global_variable()

Wir können sehen, dass die globale Variable geändert wurde. Das global_variable Name zeigt jetzt auf 'Bar':

>>> use_global_variable()
'Bar!!!'

Beachten Sie, dass "global" in Python nicht wirklich global ist - es ist nur auf der Modulebene global. Es ist also nur für Funktionen verfügbar, die in den Modulen geschrieben sind, in denen es global ist. Funktionen erinnern sich an das Modul, in dem sie geschrieben sind. Wenn sie in andere Module exportiert werden, suchen sie in dem Modul, in dem sie erstellt wurden, nach globalen Variablen.

Lokale Variablen mit demselben Namen

Wenn Sie eine lokale Variable mit demselben Namen erstellen, überschattet sie eine globale Variable:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

Die Verwendung dieser falsch benannten lokalen Variablen ändert jedoch nicht die globale Variable:

>>> use_global_variable()
'Bar!!!'

Beachten Sie, dass Sie die lokalen Variablen mit den gleichen Namen wie Globals nicht verwenden sollten, wenn Sie nicht genau wissen, was Sie tun und einen guten Grund haben, dies zu tun. Ich bin noch nicht auf einen solchen Grund gestoßen.


31
2018-01-01 19:55