web-dev-qa-db-de.com

Verwendung des "globalen" Schlüsselworts in Python

Nach dem Lesen der Dokumentation verstehe ich, dass Python über einen separaten Namespace für Funktionen verfügt. Wenn ich eine globale Variable in dieser Funktion verwenden möchte, muss ich global verwenden.

Ich benutze Python 2.7 und habe diesen kleinen Test ausprobiert

>>> sub = ['0', '0', '0', '0']
>>> def getJoin():
...     return '.'.join(sub)
...
>>> getJoin()
'0.0.0.0'

Es scheint, dass die Dinge auch ohne global gut funktionieren. Ich konnte problemlos auf globale Variablen zugreifen.

Fehlt mir etwas? Folgendes ist auch aus der Python-Dokumentation:

Namen, die in einer globalen Anweisung aufgeführt sind darf nicht als formal definiert sein Parameter oder in einer for-Loop-Steuerung Ziel, Klassendefinition, Funktion Definition oder Import-Anweisung.

Während formale Parameter und Klassendefinitionen für mich sinnvoll sind, kann ich die Einschränkung der Ziel- und Funktionsdefinition für die Schleifensteuerung nicht verstehen.

256
nik

Das Schlüsselwort global ist nur nützlich, um globale Variablen in einem lokalen Kontext zu ändern oder zu erstellen. Die Erstellung globaler Variablen wird jedoch selten als gute Lösung betrachtet.

def bob():
    me = "locally defined"    # Defined only in local context
    print me

bob()
print me     # Asking for a global variable

Die oben genannten geben Ihnen:

locally defined
Traceback (most recent call last):
  File "file.py", line 9, in <module>
    print me
NameError: name 'me' is not defined

Wenn Sie die global-Anweisung verwenden, wird die Variable "außerhalb" des Funktionsbereichs verfügbar und wird so zu einer globalen Variablen.

def bob():
    global me
    me = "locally defined"   # Defined locally but declared as global
    print me

bob()
print me     # Asking for a global variable

Der obige Code gibt Ihnen also:

locally defined
locally defined

Außerdem können Sie global aufgrund der Natur von Python verwenden, um Funktionen, Klassen oder andere Objekte in einem lokalen Kontext zu deklarieren. Ich würde zwar davon abraten, da es Albträume verursacht, wenn etwas schief geht oder ein Debugging erforderlich ist.

337
unode

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.

196
Ivo Wetzel

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
>>> 
66
pycruft

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.

47
kindall

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
12
user225312
  • 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]
6
martynas

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.

2
Jesus Ramos

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.

0
a_m_dev

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)
0
Michael

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"
0
ikostia

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

0
user7610