Warum ist das Schlüsselwort "global" nicht erforderlich, um auf eine globale Variable zuzugreifen?

Question

Nach meinem Verständnis hat Python einen separaten Namensraum für Funktionen, wenn ich also eine globale Variable in einer Funktion verwenden möchte, sollte ich wahrscheinlich global .

Allerdings konnte ich auf eine globale Variable auch ohne global :

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

Habe ich etwas übersehen?

Answer 1

• Sie können auf globale Schlüsselwörter ohne Schlüsselwort zugreifen global
• 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]

Answer 2

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, die nur innerhalb einer Funktion referenziert werden, implizit global. Wenn einer Variablen irgendwo innerhalb des Funktionskörpers ein Wert zugewiesen wird, wird angenommen, dass es sich um eine lokale Variable handelt, sofern sie nicht ausdrücklich als global deklariert ist.

Das ist zwar zunächst etwas überraschend, aber wenn man einen Moment darüber nachdenkt, erklärt sich dies. Einerseits ist es erforderlich global für zugewiesene Variablen bietet einen Schutz vor unbeabsichtigten Nebeneffekten. Andererseits, wenn global für alle globalen Verweise erforderlich wäre, würden Sie global Die ganze Zeit über. Du müsstest erklären, dass du als global jeden Verweis auf eine eingebaute Funktion oder auf eine Komponente eines importierten Moduls. Dieses Durcheinander würde die Nützlichkeit der global Erklärung zur Identifizierung von Nebenwirkungen.

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

Answer 3

Jede Variable, die außerhalb einer Funktion deklariert wird, gilt als global. Nur bei der Deklaration innerhalb von Funktionen (außer Konstruktoren) müssen Sie angeben, dass die Variable global ist.

Answer 4

global macht die Variable für alle in der Modul die modulare Reichweite so, als ob Sie es auf oberster Ebene im Modul selbst definiert hätten. Es ist außerhalb des Moduls nicht sichtbar und kann nicht aus dem Modul importiert werden, bevor es festgelegt wurde.

Wann wird global echte Probleme lösen? (Hinweis: Nur mit Python 3 geprüft.)

# Attempt #1, will fail
# We cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo1():
    import catbus
    # Now ``catbus`` is visible for anything else defined inside ``foo()`` 
    # at *compile time*
    bar()  # But ``bar()`` is a call, not a definition. ``catbus`` 
           # is invisible to it.

def bar():
    # `bar()` sees what is defined in the module
    # This works:
    print(top_level_something_or_other)
    # This doesn't work, we get an exception: NameError: name 'catbus' is not defined
    catbus.run()

Dies kann behoben werden mit global :

# Attempt #2, will work
# We still cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo2():
    import catbus
    global catbus  # Now catbus is also visible to anything defined 
                   # in the top-level module *at runtime* 
    bar()

def bar():
    # `bar` sees what is defined in the module and when run what is available at run time
    # This still works:
    print(top_level_something_or_other)
    # This also works now:
    catbus.run()

Dies wäre nicht notwendig, wenn bar() wurde definiert innerhalb foo etwa so:

# Attempt 3, will work
# We cannot import ``catbus`` here
# as that would lead to an import loop somewhere else,
# or importing ``catbus`` is so expensive that you don't want to 
# do it automatically  when importing this module

top_level_something_or_other = None

def foo3():

    def bar():
        # ``bar()`` sees what is defined in the module *and* what is defined in ``foo()``
        print(top_level_something_or_other)
        catbus.run()

    import catbus
    # Now catbus is visible for anything else defined inside foo() at *compile time*
    bar()  # Which now includes bar(), so this works

Durch die Definition bar() außerhalb von foo() , bar() kann in etwas importiert werden, das puede importieren catbus direkt oder als Attrappe, wie in einem Einheitstest.

global ist ein Codegeruch, aber manchmal braucht man genau einen schmutzigen Hack wie global . Wie auch immer, "global" ist ein schlechter Name dafür, da es so etwas wie einen globalen Bereich in Python nicht gibt, es sind Module den ganzen Weg nach unten.

Answer 5

Das 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"