Доступ к переменной за пределами функции внутри функции [duplicate]

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

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, чтобы изменить ее.

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

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"

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

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

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

value = 42

def doit():
    print value
    value = 0

doit()
print value

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

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

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

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)

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

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

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

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

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

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

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

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