Quello che capisco leggendo la documentazione è che Python ha uno spazio dei nomi separato per le funzioni e se voglio usare una variabile globale in quella funzione, devo usare global.

Sto usando Python 2.7 e ho provato questo piccolo test

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

Sembra che le cose funzionino bene anche senza global. Sono stato in grado di accedere alla variabile globale senza alcun problema.

Mi sto perdendo qualcosa? Inoltre, ciò che segue è dalla documentazione di Python:

I nomi elencati in un'istruzione globale non devono essere definiti come parametri formali o in una destinazione di controllo del ciclo for, definizione di classe, definizione di funzione o istruzione di importazione.

Sebbene i parametri formali e la definizione della classe abbiano senso per me, non sono in grado di comprendere la limitazione per la definizione del target di controllo del loop e la definizione della funzione.

La parola chiave globalè utile solo per modificare o creare variabili globali in un contesto locale, sebbene la creazione di variabili globali sia raramente considerata una buona soluzione.

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

bob()
print(me)     # Asking for a global variable

Quanto sopra ti darà:

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

Mentre se usi l' globalistruzione, la variabile diventerà disponibile "al di fuori" dell'ambito della funzione, diventando effettivamente una variabile globale.

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

bob()
print(me)     # Asking for a global variable

Quindi il codice sopra ti darà:

locally defined
locally defined

Inoltre, a causa della natura di Python, è possibile utilizzare anche globalper dichiarare funzioni, classi o altri oggetti in un contesto locale. Anche se lo sconsiglio dal momento che provoca incubi se qualcosa va storto o necessita di debug.

Mentre puoi accedere alle variabili globali senza la globalparola chiave, se vuoi modificarle devi usare la globalparola chiave. Per esempio:

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

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

Nel tuo caso, stai solo accedendo all'elenco sub.

Questa è la differenza tra accedere al nome e vincolarlo in un ambito.

Se stai solo cercando una variabile per leggerne il valore, hai accesso all'ambito globale e locale.

Tuttavia, se si assegna a una variabile il cui nome non è nell'ambito locale, si vincola quel nome a questo ambito (e se quel nome esiste anche come globale, lo si nasconderà).

Se si desidera essere in grado di assegnare al nome globale, è necessario indicare al parser di utilizzare il nome globale anziché associare un nuovo nome locale, che è ciò che fa la parola chiave "globale".

Associare un punto qualsiasi all'interno di un blocco fa sì che il nome ovunque in quel blocco venga associato, il che può causare conseguenze piuttosto strane (ad esempio UnboundLocalError che appare improvvisamente nel codice precedentemente funzionante).

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

Le altre risposte rispondono alla tua domanda. Un'altra cosa importante da sapere sui nomi in Python è che sono locali o globali in base all'ambito.

Considera questo, ad esempio:

value = 42

def doit():
    print value
    value = 0

doit()
print value

Probabilmente puoi immaginare che l' value = 0istruzione verrà assegnata a una variabile locale e non influirà sul valore della stessa variabile dichiarata all'esterno della doit()funzione. Potresti essere più sorpreso di scoprire che il codice sopra non verrà eseguito. L'istruzione print valueall'interno della funzione produce unUnboundLocalError.

Il motivo è che Python ha notato che, altrove nella funzione, si assegna il nome valuee inoltre valuenon è stato dichiarato da nessuna parte global. Questo lo rende una variabile locale. Ma quando si tenta di stamparlo, il nome locale non è stato ancora definito. Python in questo caso non ricorre alla ricerca del nome come variabile globale, come fanno alcune altre lingue. In sostanza, non è possibile accedere a una variabile globale se è stata definita una variabile locale con lo stesso nome in qualsiasi punto della funzione.

L'accesso a un nome e l'assegnazione di un nome sono diversi. Nel tuo caso, stai solo accedendo a un nome.

Se si assegna a una variabile all'interno di una funzione, si presume che tale variabile sia locale a meno che non venga dichiarata globale. In assenza di ciò, si presume che sia globale.

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

• Puoi accedere a parole chiave globali senza parola chiave global
• Per poterli modificare è necessario dichiarare esplicitamente che la parola chiave è globale. In caso contrario, la parola chiave verrà dichiarata nell'ambito locale.

Esempio:

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]

Si presume che qualsiasi variabile dichiarata al di fuori di una funzione sia globale, è solo quando si dichiarano dall'interno di funzioni (eccetto i costruttori) che è necessario specificare che la variabile è globale.

Questo è spiegato bene nelle FAQ di Python

Quali sono le regole per le variabili locali e globali in Python?

In Python, le variabili a cui viene fatto riferimento solo all'interno di una funzione sono implicitamente globali. Se a una variabile viene assegnato un valore in qualsiasi punto del corpo della funzione, si presume che sia un valore locale se non esplicitamente dichiarato globale.

Anche se all'inizio è un po 'sorprendente, un attimo di considerazione lo spiega. Da un lato, la richiesta globaldi variabili assegnate fornisce una barra contro gli effetti collaterali indesiderati. D'altra parte, se globalfosse richiesto per tutti i riferimenti globali, saresti sempre in uso global. Dovresti dichiarare come globalogni riferimento a una funzione integrata o a un componente di un modulo importato. Questo disordine vanificherebbe l'utilità della globaldichiarazione per identificare gli effetti collaterali.

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

Significa che non dovresti fare quanto segue:

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"

Global rende la variabile "Global"

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


out()

print (x)

Questo fa 'x' agire come una normale variabile al di fuori della funzione. Se si eliminasse il globale, si darebbe un errore poiché non è possibile stampare una variabile all'interno di una funzione.

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)