Из прочтения документации я понимаю, что в Python есть отдельное пространство имен для функций, и если я хочу использовать глобальную переменную в этой функции, мне нужно ее использовать global.

Я использую Python 2.7, и я попробовал этот маленький тест

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

Кажется, все работает нормально, даже без global. Я смог получить доступ к глобальной переменной без каких-либо проблем.

Я что-то упустил? Кроме того, следующее из документации по Python:

Имена, перечисленные в глобальном операторе, не должны быть определены как формальные параметры или как цель управления циклом for, определение класса, определение функции или оператор импорта.

В то время как формальные параметры и определение класса имеют смысл для меня, я не могу понять ограничение для цели управления циклом и определения функции.

Ключевое слово globalполезно только для изменения или создания глобальных переменных в локальном контексте, хотя создание глобальных переменных редко считается хорошим решением.

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

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

Вышеуказанное даст вам:

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

Если вы используете globalоператор, переменная станет доступной «вне» области действия функции, фактически превратившись в глобальную переменную.

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

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

Таким образом, приведенный выше код даст вам:

locally defined
locally defined

Кроме того, из-за природы Python, вы также можете использовать globalдля объявления функций, классов или других объектов в локальном контексте. Хотя я бы посоветовал против этого, так как это вызывает кошмары, если что-то идет не так или требует отладки.

Хотя вы можете получить доступ к глобальным переменным без globalключевого слова, если вы хотите изменить их, вы должны использовать globalключевое слово. Например:

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

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

В вашем случае вы просто получаете доступ к списку sub.

В этом разница между доступом к имени и привязке его в области видимости.

Если вы просто ищете переменную, чтобы прочитать ее значение, вы получите доступ к глобальной и локальной области видимости.

Однако если вы присваиваете переменную, имя которой не входит в локальную область, вы привязываете это имя к этой области (и если это имя также существует как глобальное, вы его скрываете).

Если вы хотите иметь возможность присваивать глобальное имя, вам нужно указать парсеру использовать глобальное имя, а не связывать новое локальное имя - это то, что делает ключевое слово «global».

Привязка в любом месте блока приводит к тому, что имя в этом блоке становится связанным, что может вызвать некоторые довольно странные последствия (например, UnboundLocalError, внезапно появляющийся в ранее работающем коде).

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

Другие ответы отвечают на ваш вопрос. Еще одна важная вещь, которую нужно знать об именах в Python, это то, что они являются локальными или глобальными для каждой области действия.

Рассмотрим это, например:

value = 42

def doit():
    print value
    value = 0

doit()
print value

Вы, вероятно, можете догадаться, что value = 0оператор будет присваивать локальную переменную и не повлияет на значение той же переменной, объявленной вне doit()функции. Вы можете быть более удивлены, обнаружив, что приведенный выше код не будет работать. Заявлениеprint value внутри функции производитUnboundLocalError.

Причина в том, что Python заметил, что в другом месте функции вы присваиваете имя value, а также valueнигде не объявляется global. Это делает его локальной переменной. Но когда вы пытаетесь распечатать его, локальное имя еще не определено. В этом случае Python не прибегает к поиску имени как глобальной переменной, как это делают некоторые другие языки. По сути, вы не можете получить доступ к глобальной переменной, если вы определили локальную переменную с тем же именем в любом месте функции.

Доступ к имени и присвоение имени отличаются. В вашем случае вы просто получаете доступ к имени.

Если вы присваиваете переменную внутри функции, эта переменная считается локальной, если вы не объявили ее глобальной. В отсутствие этого он считается глобальным.

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

• Вы можете получить доступ к глобальным ключевым словам без ключевого слова global
• Чтобы иметь возможность их изменять, вам необходимо явно указать, что ключевое слово является глобальным. В противном случае ключевое слово будет объявлено в локальной области.

Пример:

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]

Предполагается, что любая переменная, объявленная вне функции, является глобальной, и только если вы объявляете их изнутри функций (кроме конструкторов), вы должны указать, что эта переменная будет глобальной.

Это хорошо объясняется в FAQ по Python

Каковы правила для локальных и глобальных переменных в Python?

В Python переменные, на которые ссылаются только внутри функции, неявно являются глобальными. Если переменной присваивается значение где-либо в теле функции, она считается локальной, если явно не объявлена ​​как глобальная.

Хотя поначалу это немного удивляет, это можно объяснить моментально. С одной стороны, требование globalназначенных переменных обеспечивает защиту от непреднамеренных побочных эффектов. С другой стороны, если бы это globalбыло необходимо для всех глобальных ссылок, вы бы использовали globalвсе время. Вы должны будете объявить globalкаждую ссылку на встроенную функцию или компонент импортируемого модуля. Этот беспорядок отрицает полезность globalдекларации для выявления побочных эффектов.

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

Это означает, что вы не должны делать следующее:

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"

Глобал делает переменную "Глобал"

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


out()

print (x)

Это заставляет 'x' действовать как обычная переменная вне функции. Если вы вынули глобальную переменную, это выдаст ошибку, поскольку она не может распечатать переменную внутри функции.

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)