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

Das Schreiben auf explizite Elemente eines globalen Arrays erfordert offenbar keine globale Deklaration, obwohl das Schreiben auf das Array "im Ganzen" diese Anforderung stellt:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

Answer 2

Ich füge dies hinzu, da ich es in keiner der anderen Antworten gesehen habe und es für jemanden, der mit etwas Ähnlichem zu kämpfen hat, nützlich sein könnte. Die globals() Funktion gibt ein veränderbares globales Symbolverzeichnis zurück, in dem Sie Daten für den Rest Ihres Codes "magisch" verfügbar machen können. Zum Beispiel:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

y

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

Lässt Sie einfach Variablen aus dem und in den globalen Namespace dumpen/laden. Superpraktisch, kein Durcheinander, kein Aufhebens. Ziemlich sicher, dass es nur Python 3 ist.

Answer 3

global_var = 10  # will be considered as a global variable

def func_1():
    global global_var  # access variable using variable keyword
    global_var += 1

def func_2():
    global global_var
    global_var *= 2
    print(f"func_2: {global_var}")

func_1()
func_2()
print("Global scope:", global_var) # will print 22

Erläuterung:

global_var ist eine globale Variable und alle Funktionen und Klassen können auf diese Variable zugreifen.

Die func_1() auf diese globale Variable mit dem Schlüsselwort global die auf die Variable zeigt, die in den globalen Bereich geschrieben wird. Wenn ich das globale Schlüsselwort nicht geschrieben hätte, würde die Variable global_var innerhalb func_1 wird als lokale Variable betrachtet, die nur innerhalb der Funktion verwendet werden kann. Dann wird innerhalb func_1 habe ich diese globale Variable um 1 erhöht.

Das Gleiche geschah in func_2() .

Nach dem Aufruf func_1 y func_2 sehen Sie die global_var geändert wird

Answer 4

Verweisen Sie auf den Klassennamensraum, in dem die Änderung angezeigt werden soll.

In diesem Beispiel verwendet der Läufer max aus der Datei config. Ich möchte, dass mein Test den Wert von max wenn der Läufer sie benutzt.

main/config.py

max = 15000

main/runner.py

from main import config
def check_threads():
    return max < thread_count 

tests/runner_test.py

from main import runner                # <----- 1. add file
from main.runner import check_threads
class RunnerTest(unittest):
   def test_threads(self):
       runner.max = 0                  # <----- 2. set global 
       check_threads()

Answer 5

Globale sind in Ordnung - außer bei Multiprocessing

Globals in Verbindung mit Multiprocessing auf unterschiedlichen Plattformen/Umgebungen wie Windows/Mac OS auf der einen Seite und Linux auf der anderen Seite sind mühsam.

Ich werde Ihnen dies anhand eines einfachen Beispiels zeigen, das auf ein Problem hinweist, auf das ich vor einiger Zeit gestoßen bin.

Wenn Sie verstehen wollen, warum die Dinge unter Windows/MacOs und Linux unterschiedlich sind, dann müssen Sie wissen, dass der Standardmechanismus zum Starten eines neuen Prozesses unter ...

• Windows/MacOs ist "Laich
• Linux ist eine "Gabelung

Sie unterscheiden sich in der Speicherzuweisung und Initialisierung ... (aber darauf gehe ich hier nicht ein hier).

Werfen wir einen Blick auf das Problem/Beispiel ...

import multiprocessing

counter = 0

def do(task_id):
    global counter
    counter +=1
    print(f'task {task_id}: counter = {counter}')

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=4)
    task_ids = list(range(4))
    pool.map(do, task_ids)

Windows

Wenn Sie dies unter Windows ausführen (und ich nehme an, auch unter MacOS), erhalten Sie folgende Ausgabe ...

task 0: counter = 1
task 1: counter = 2
task 2: counter = 3
task 3: counter = 4

Linux

Wenn Sie dies unter Linux ausführen, erhalten Sie stattdessen das folgende Ergebnis.

task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1