Verwendung des "globalen" Schlüsselworts in Python

Während Sie ohne das Schlüsselwort global auf globale Variablen zugreifen können, müssen Sie das Schlüsselwort global verwenden, wenn Sie sie ändern möchten. Zum Beispiel:

foo = 1
def test():
    foo = 2 # new local foo

def blub():
    global foo
    foo = 3 # changes the value of the global foo

In Ihrem Fall greifen Sie nur auf die Liste sub zu.

Dies ist der Unterschied zwischen dem Zugriff auf den Namen und Bindung innerhalb eines Bereichs.

Wenn Sie nur nach einer Variablen suchen, um deren Wert zu lesen, haben Sie sowohl Zugriff auf den globalen als auch auf den lokalen Bereich.

Wenn Sie jedoch einer Variablen zuweisen, deren Name nicht im lokalen Bereich liegt, haben Sie binding diesen Namen in diesem Bereich (und wenn dieser Name auch als global vorhanden ist, blenden Sie ihn aus). 

Wenn Sie den globalen Namen zuweisen möchten, müssen Sie dem Parser mitteilen, dass er den globalen Namen verwenden soll, anstatt einen neuen lokalen Namen zu binden. Dies ist das Schlüsselwort 'global'.

Das Binden an eine beliebige Stelle innerhalb eines Blocks bewirkt, dass der Name überall in diesem Block gebunden wird. Dies kann zu recht seltsam aussehenden Folgen führen (z. B. UnboundLocalError, das plötzlich in zuvor funktionierendem Code vorkommt).

>>> a = 1
>>> def p():
    print(a) # accessing global scope, no binding going on
>>> def q():
    a = 3 # binding a name in local scope - hiding global
    print(a)
>>> def r():
    print(a) # fail - a is bound to local scope, but not assigned yet
    a = 4
>>> p()
1
>>> q()
3
>>> r()
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    r()
  File "<pyshell#32>", line 2, in r
    print(a) # fail - a is bound to local scope, but not assigned yet
UnboundLocalError: local variable 'a' referenced before assignment
>>> 

Die anderen Antworten beantworten Ihre Frage. Eine weitere wichtige Sache, die Sie über Namen in Python wissen sollten, ist, dass sie entweder lokal oder global sind.

Betrachten Sie dies zum Beispiel:

value = 42

def doit():
    print value
    value = 0

doit()
print value

Sie können wahrscheinlich davon ausgehen, dass die value = 0-Anweisung einer lokalen Variablen zugewiesen wird und sich nicht auf den Wert derselben Variablen auswirkt, die außerhalb der doit()-Funktion deklariert ist. Sie werden überrascht sein, dass der obige Code nicht ausgeführt wird. Die Anweisung print value in der Funktion erzeugt einen UnboundLocalError.

Der Grund ist, dass Python festgestellt hat, dass Sie an anderer Stelle in der Funktion den Namen value zuweisen, und außerdem value nirgends global deklariert ist. Das macht es zu einer lokalen Variablen. Wenn Sie jedoch versuchen, es zu drucken, wurde der lokale Name noch nicht definiert. Python in diesem Fall greift nicht auf zurück, um den Namen als globale Variable zu suchen, wie in anderen Sprachen. Grundsätzlich können Sie nicht auf eine globale Variable zugreifen, wenn Sie eine lokale Variable mit dem gleichen Namen überall in der Funktion definiert haben.

Der Zugriff auf einen Namen und das Zuweisen eines Namens sind unterschiedlich. In Ihrem Fall greifen Sie nur auf einen Namen zu.

Wenn Sie eine Variable innerhalb einer Funktion zuweisen, wird davon ausgegangen, dass diese Variable lokal ist, sofern Sie sie nicht als global deklarieren. Wenn dies nicht der Fall ist, wird angenommen, dass es global ist.

>>> x = 1         # global 
>>> def foo():
        print x       # accessing it, it is global

>>> foo()
1
>>> def foo():   
        x = 2        # local x
        print x 

>>> x            # global x
1
>>> foo()        # prints local x
2

• Sie können auf globale Schlüsselwörter ohne Schlüsselwort global zugreifen.
• Um sie ändern zu können, müssen Sie ausdrücklich angeben, dass das Schlüsselwort global ist. Andernfalls wird das Schlüsselwort im lokalen Bereich deklariert.

Beispiel:

words = [...] 

def contains (Word): 
    global words             # <- not really needed
    return (Word in words) 

def add (Word): 
    global words             # must specify that we're working with a global keyword
    if Word not in words: 
        words += [Word]

Jede Variable, die außerhalb einer Funktion deklariert wird, wird als global angenommen. Nur wenn Sie sie innerhalb von Funktionen deklarieren (außer Konstruktoren), müssen Sie angeben, dass die Variable global ist.

ich werde Ihnen ein einfaches Beispiel geben: Denken Sie über diesen Code nach: 

myVar = 0 
print (myVar )      # 01 line: returns 0

def func():
    myVar  = "def"
    print (myVar )

func()              # 02 line: returns def
print (myVar )      # 03 line: returns 0

wie Sie sehen, gibt die letzte Codezeile 0 zurück, da innerhalb der Funktion die Variable myVar nicht neu zugewiesen wurde. Sie wurde lediglich geändert und ändert nur beim Aufruf der Funktion, ohne die Hauptvariable myVar zu beeinflussen , weil es in unserer Funktion definiert ist (bedeutet, dass es sich um eine lokale Variable handelt), wobei jedoch das globale Schlüsselwort als solches verwendet wird:

 myVar  = 0 
print (myVar )       # 01 Line : returns 0

def func():
    global myVar 
    myVar  = "def"
    print (myVar )

func()               # 02 Line : returns def
print (myVar )       # 03 Line : returns def

wir ordnen Python tatsächlich so an, dass diese Variable in def nicht lokal ist. Verwenden Sie die globale Variable myVar, um sie zu ändern.

Global macht die Variable "Global"

def out():
    global x
    x = 1
    print(x)
    return


out()

print (x)

Dadurch wirkt 'x' wie eine normale Variable außerhalb der Funktion. Wenn Sie das globale Element herausnehmen, wird ein Fehler ausgegeben, da es keine Variablen innerhalb einer Funktion drucken kann.

def out():
     # Taking out the global will give you an error since the variable x is no longer 'global' or in other words: accessible for other commands
    x = 1
    print(x)
    return


out()

print (x)

Es bedeutet, dass Sie Folgendes nicht tun sollten:

x = 1

def myfunc():
  global x

  # formal parameter
  def localfunction(x):
    return x+1

  # import statement
  import os.path as x

  # for loop control target
  for x in range(10):
    print x

  # class definition
  class x(object):
    def __init__(self):
      pass

  #function definition
  def x():
    print "I'm bad"

Dies wird in den Python FAQ gut erklärt

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

In Python sind Variablen, auf die nur innerhalb einer Funktion verwiesen wird, implizit global. Wenn einer Variablen irgendwo im Funktionskörper ein Wert zugewiesen wird, wird davon ausgegangen, dass es sich um eine lokale Variable handelt, sofern dies nicht ausdrücklich als global deklariert wird.

Zunächst etwas überraschend, erklärt dies jedoch eine kurze Überlegung. Einerseits bietet die Anforderung von global für zugewiesene Variablen einen Schutz vor unbeabsichtigten Nebenwirkungen. Wenn dagegen global für alle globalen Verweise erforderlich wäre, würden Sie global die ganze Zeit verwenden. Sie müssen jeden Verweis auf eine integrierte Funktion oder auf eine Komponente eines importierten Moduls als global deklarieren. Diese Unordnung würde die Nützlichkeit der global -Deklaration zur Identifizierung von Nebenwirkungen zunichte machen.

https://docs.python.org/3/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python