Verwendung globaler Variablen in einer Funktion

Question

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

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

Answer 1

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

Mit der folgenden Funktion können wir ein Global 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' 

Wenn Sie eine Funktion schreiben, wird ihr Code nicht tatsächlich ausgeführt. Wir rufen also die create_global_variable Funktion:

>>> create_global_variable()

Verwendung von Globals ohne Änderung

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

Zum Beispiel,

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 richten, müssen Sie erneut das Schlüsselwort global 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 ändert, noch nicht ausgeführt wurde:

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

Also nach dem Aufruf der Funktion:

>>> change_global_variable()

können wir sehen, dass die globale Variable geändert wurde. Die global_variable name zeigt nun auf 'Bar' :

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

Beachten Sie, dass "global" in Python nicht wirklich global ist - es ist nur global für die Modulebene. Es ist also nur für Funktionen verfügbar, die in den Modulen geschrieben wurden, in denen es global ist. Funktionen merken sich das Modul, in dem sie geschrieben wurden. Wenn sie also in andere Module exportiert werden, suchen sie weiterhin 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 diese 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!!!'

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

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

Beachten Sie, dass Sie es vermeiden sollten, lokale Variablen mit demselben Namen wie globale Variablen zu verwenden, es sei denn, Sie wissen genau, was Sie tun, und haben einen sehr guten Grund dafür. Ein solcher Grund ist mir noch nicht begegnet.

Das gleiche Verhalten zeigt sich im Unterricht

In einem Folgekommentar wird gefragt:

Was ist zu tun, wenn ich eine globale Variable in einer Funktion innerhalb einer Klasse erstellen und diese Variable in einer anderen Funktion innerhalb einer anderen Klasse verwenden möchte?

Hier zeige ich, dass wir in Methoden das gleiche Verhalten wie in regulären Funktionen erhalten:

class Foo:
    def foo(self):
        global global_variable
        global_variable = 'Foo'

class Bar:
    def bar(self):
        return global_variable + '!!!'

Foo().foo()

Und jetzt:

>>> Bar().bar()
'Foo!!!'

Ich würde jedoch vorschlagen, statt globaler Variablen Klassenattribute zu verwenden, um den Modul-Namensraum nicht zu überfrachten. Beachten Sie auch, dass wir nicht self Argumente hier - dies könnten Klassenmethoden sein (praktisch, wenn man das Klassenattribut von der üblichen cls Argument) oder statische Methoden (kein self o cls ).

Answer 2

Zusätzlich zu den bereits vorhandenen Antworten und um die Sache noch verwirrender zu machen:

In Python sind Variablen, die nur innerhalb einer Funktion referenziert werden implizit global . Wenn einer Variablen irgendwo im Funktionskörper ein neuer Wert zugewiesen wird innerhalb des Funktionskörpers zugewiesen wird, wird angenommen, dass es sich um eine . . Wenn eine Variable innerhalb der Funktion ein neuer Wert zugewiesen wird, ist die Variable implizit lokal, und Sie müssen sie ausdrücklich als "global" deklarieren.

Auch wenn es auf den ersten Blick etwas überraschend ist, so erklärt es sich bei näherer Betrachtung dies. Einerseits bietet die Forderung nach globalen Variablen für zugewiesene Variablen ein Barriere gegen unbeabsichtigte Nebeneffekte. Auf der anderen Seite, wenn global für alle für alle globalen Referenzen erforderlich wäre, würden Sie ständig global verwenden ständig verwenden. Man müsste jeden Verweis auf eine eingebaute Funktion oder auf eine Komponente eines importierten Moduls als global deklarieren. Dieses Durcheinander würde würde die Nützlichkeit der globalen Deklaration zur Identifizierung von Nebeneffekte.

Source : Was sind die Regeln für lokale und globale Variablen in Python? .

Answer 3

Bei der parallelen Ausführung können globale Variablen zu unerwarteten Ergebnissen führen, wenn Sie nicht verstehen, was da vor sich geht. Hier ist ein Beispiel für die Verwendung einer globalen Variable im Rahmen von Multiprozessing. Man sieht deutlich, dass jeder Prozess mit seiner eigenen Kopie der Variablen arbeitet:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

Ausgabe:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

Answer 4

Wie sich herausstellt, ist die Antwort immer einfach.

Hier ist ein kleines Beispielmodul mit einer einfachen Möglichkeit, es in einer main Definition:

def five(enterAnumber,sumation):
    global helper
    helper  = enterAnumber + sumation

def isTheNumber():
    return helper

So zeigen Sie es in einer main Definition:

import TestPy

def main():
    atest  = TestPy
    atest.five(5,8)
    print(atest.isTheNumber())

if __name__ == '__main__':
    main()

Dieser einfache Code funktioniert genau so, und er wird ausgeführt. Ich hoffe, es hilft.

Answer 5

Was Sie sagen, ist, dass Sie die Methode wie folgt anwenden sollten:

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

Besser ist es jedoch, die globale Variable wie folgt zu verwenden:

globvar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

Beide liefern das gleiche Ergebnis.