Python function global variables? [duplicate]

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

x = "somevalue"

def func_A ():
   global x
   # Do things to x
   return x

def func_B():
   x = func_A()
   # Do things
   return x

func_A()
func_B()

Имеет ли значение, x которое использует вторая функция, то же значение, что и глобальная копия, x которая func_a использует и изменяет? При вызове функций после определения имеет значение порядок?

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

Например.

global someVar
someVar = 55

Это изменило бы значение глобальной переменной на 55. В противном случае она просто присвоила бы 55 локальной переменной.

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

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

Давайте посмотрим на модифицированную версию вашего псевдокода, чтобы увидеть, что происходит:

# Here, we're creating a variable 'x', in the __main__ scope.
x = 'None!'

def func_A():
  # The below declaration lets the function know that we
  #  mean the global 'x' when we refer to that variable, not
  #  any local one

  global x
  x = 'A'
  return x

def func_B():
  # Here, we are somewhat mislead.  We're actually involving two different
  #  variables named 'x'.  One is local to func_B, the other is global.

  # By calling func_A(), we do two things: we're reassigning the value
  #  of the GLOBAL x as part of func_A, and then taking that same value
  #  since it's returned by func_A, and assigning it to a LOCAL variable
  #  named 'x'.     
  x = func_A() # look at this as: x_local = func_A()

  # Here, we're assigning the value of 'B' to the LOCAL x.
  x = 'B' # look at this as: x_local = 'B'

  return x # look at this as: return x_local

На самом деле, вы могли бы переписать все из func_B с помощью переменной с именем x_local, и это работало бы идентично.

Порядок имеет значение только в том порядке, в котором ваши функции выполняют операции, изменяющие значение глобального x . Таким образом, в нашем примере порядок не имеет значения, поскольку func_B вызывает func_A. В этом примере порядок имеет значение:

def a():
  global foo
  foo = 'A'

def b():
  global foo
  foo = 'B'

b()
a()
print foo
# prints 'A' because a() was the last function to modify 'foo'.

Обратите внимание, что global требуется только для изменения глобальных объектов. Вы по-прежнему можете получить к ним доступ из функции без объявления global.
Таким образом, мы имеем:

x = 5

def access_only():
  return x
  # This returns whatever the global value of 'x' is

def modify():
  global x
  x = 'modified'
  return x
  # This function makes the global 'x' equal to 'modified', and then returns that value

def create_locally():
  x = 'local!'
  return x
  # This function creates a new local variable named 'x', and sets it as 'local',
  #  and returns that.  The global 'x' is untouched.

Обратите внимание, разница между create_locally и access_only -- access_only заключается в доступе к глобальному x, несмотря на то, что он не вызывается global, и даже несмотря на то, что он create_locallyтакже не использует global, он создает локальную копию, поскольку он присваивает значение.

Путаница здесь в том, почему вы не должны использовать глобальные переменные.

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

var = 1
def global_var_change():
      global var
      var = "value changed"
global_var_change() #call the function for changes
print var

Вообще говоря, это не очень хорошая практика программирования. Из-за нарушения логики пространства имен код может стать трудным для понимания и отладки.

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

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

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

d = {}
l = []
o = type("object", (object,), {})()

def valid():     # these are all valid without declaring any names global!
   d[0] = 1      # changes what's in d, but d still points to the same object
   d[0] += 1     # ditto
   d.clear()     # ditto! d is now empty but it`s still the same object!
   l.append(0)   # l is still the same list but has an additional member
   o.test = 1    # creating new attribute on o, but o is still the same object