Использование ключевого слова "global" в Python

Ответ 1

Ключевое слово 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 для объявления функций, классов или других объектов в локальном контексте. Хотя я бы советовал против этого, поскольку он вызывает кошмары, если что-то пошло не так или требует отладки.

Ответ 2

Пока вы можете обращаться к глобальным переменным без ключевого слова 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.

Ответ 3

Это разница между доступом к имени и привязкой к нему в пределах области.

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

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

Если вы хотите назначить глобальное имя, вам нужно сказать, что синтаксический анализатор использует глобальное имя, а не связывает новое локальное имя - это то, что делает ключевое слово "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
>>> 

Ответ 4

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

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

value = 42

def doit():
    print value
    value = 0

doit()
print value

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

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

Ответ 5

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

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

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

Ответ 6

• Вы можете получить доступ к глобальным ключевым словам без ключевого слова 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]

Ответ 7

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

Ответ 8

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

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"

Ответ 9

Global делает переменную "Global"

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)

Ответ 10

я дам вам простой пример: подумайте об этом коде:

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

так как вы можете видеть, что последняя строка кода вернет 0, потому что внутри функции переменная myVar не была переназначена, ее только что было изменено, и она изменится только тогда, когда вызванная функция не влияет на основную переменную myVar, поскольку она определена внутри наша функция (означает, что это локальная переменная), но с использованием глобального ключевого слова как такового:

 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

мы фактически заказываем python, что эта переменная внутри def не является локальной, используйте глобальную переменную с именем myVar, как ее изменить.