überschreiben - python variable übergeben




Verwendung globaler Variablen in einer Funktion (12)

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, für die der Zugriff erforderlich ist?


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

Wir können ein Global 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' 

Beim Schreiben einer Funktion wird der Code nicht ausgeführt. Also rufen wir die Funktion create_global_variable :

>>> create_global_variable()

Verwendung von Globals ohne Modifikation

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

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 aus einer Funktion heraus

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 der Code, der tatsächlich geändert wurde, nach dem Schreiben dieser Funktion 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. Der global_variable Name zeigt jetzt auf 'Bar' :

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

Beachten Sie, dass "global" in Python nicht wirklich global ist, sondern nur auf Modulebene. Es ist also nur für Funktionen verfügbar, die in den Modulen geschrieben werden, in denen es global ist. Funktionen erinnern sich an das Modul, in dem sie geschrieben wurden. Wenn sie also in andere Module exportiert werden, suchen sie immer noch in dem Modul, in dem sie erstellt wurden, um globale Variablen zu finden.

Lokale Variablen mit demselben Namen

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

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 Variable ändert jedoch nicht die globale Variable:

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

Beachten Sie, dass Sie lokale Variablen nicht mit denselben Namen wie Globals verwenden sollten, es sei denn, Sie wissen genau, was Sie tun, und haben einen guten Grund, dies zu tun. Ich bin noch keinem solchen Grund begegnet.


Bei der parallelen Ausführung können globale Variablen zu unerwarteten Ergebnissen führen, wenn Sie nicht wissen, was passiert. Hier ist ein Beispiel für die Verwendung einer globalen Variablen in Multiprocessing. Wir können deutlich erkennen, dass jeder Prozess mit einer 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]

Falls Sie eine lokale Variable mit demselben Namen haben, möchten Sie möglicherweise die Funktion globals() verwenden .

globals()['your_global_var'] = 42

Ich füge das hinzu, da ich es in keiner der anderen Antworten gesehen habe und es könnte nützlich sein, wenn jemand mit etwas Ähnlichem kämpft. Die Funktion globals () gibt ein veränderliches globales Symbolwörterbuch zurück, in dem Sie Daten für den Rest Ihres Codes "magisch" zur Verfügung stellen 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

und

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

Sie können nur Variablen aus dem und in den globalen Namespace laden / laden. Super praktisch, kein Muss, kein Aufwand. Ziemlich sicher, dass es nur Python 3 ist.


Python verwendet eine einfache Heuristik, um zu entscheiden, aus welchem ​​Bereich eine Variable zwischen lokal und global geladen werden soll. Wenn ein Variablenname auf der linken Seite einer Zuweisung angezeigt wird, jedoch nicht als global deklariert wird, wird davon ausgegangen, 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        
>>> 

Sehen Sie, wie baz, die auf der linken Seite einer Zuweisung in foo() LOAD_FAST wird, die einzige LOAD_FAST Variable ist.


Sie müssen die globale Variable in jeder Funktion referenzieren, die Sie verwenden möchten.

Wie folgt:

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""

Versuche dies:

def x1():
    global x
    x = 6

def x2():
    global x
    x = x+1
    print x

x = 5
x1()
x2()  # output --> 7

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 ändert, wenn der Läufer ihn verwendet.

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()

Was Sie sagen, ist die Methode wie folgt zu verwenden:

globvar = 5

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

f()  # Prints 5

Der bessere Weg ist jedoch, die globale Variable folgendermaßen zu verwenden:

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

Beide geben die gleiche Ausgabe.


Wenn Sie in einer Funktion auf eine globale Variable verweisen möchten, können Sie mit dem globalen Schlüsselwort angeben, welche Variablen global sind. Sie müssen es nicht in allen Fällen verwenden (wie jemand falsch behauptet). Wenn der Name, auf den in einem Ausdruck verwiesen wird, nicht im lokalen Bereich oder Bereich in den Funktionen gefunden werden kann, in denen diese Funktion definiert ist, wird er unter 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 eine vorhandene globale Variable mit demselben Namen überschatten.

Globale Variablen sind auch nützlich, im Gegensatz zu einigen OOP-Eiferern, die etwas anderes behaupten - insbesondere für kleinere Skripts, bei denen OOP ein Overkill ist.


Wie sich herausstellt, ist die Antwort immer einfach.

Hier ist ein kleines Beispielmodul mit einer einfachen Möglichkeit, es in einer Hauptdefinition darzustellen:

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

def isTheNumber():
    return helper

So zeigen Sie es in einer Hauptdefinition:

import TestPy

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

if __name__ == '__main__':
    main()

Dieser einfache Code funktioniert genauso und wird ausgeführt. Ich hoffe, es hilft.


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

In Python sind Variablen, auf die nur innerhalb einer Funktion verwiesen wird, implizit global . Wenn einer Variablen irgendwo innerhalb des Funktionskörpers ein neuer Wert zugewiesen wird, wird angenommen, dass es sich um einen lokalen Wert handelt. Wenn einer Variablen immer ein neuer Wert innerhalb der Funktion zugewiesen wird, ist die Variable implizit lokal und Sie müssen sie explizit als "global" deklarieren.

Obwohl dies zunächst ein wenig überraschend ist, erklärt dies eine Momentbetrachtung. Auf der einen Seite bietet das Erfordernis global für zugewiesene Variablen einen Balken gegen unbeabsichtigte Nebenwirkungen. Wenn dagegen global für alle globalen Referenzen erforderlich wäre, würden Sie immer global verwenden. Sie müssen jeden Verweis auf eine eingebaute Funktion oder auf eine Komponente eines importierten Moduls als global deklarieren. Dieses Durcheinander würde die Nützlichkeit der globalen Erklärung zur Identifizierung von Nebenwirkungen zunichte machen.

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







scope