Глобальные переменные функции Python?
Я знаю, что мне следует избегать использования глобальных переменных в первую очередь из-за подобной путаницы, но если бы я их использовал, является ли следующий действительный способ их использования? (Я пытаюсь вызвать глобальную копию переменной, созданную в отдельной функции.)
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
использует и изменяет? При вызове функций после определения имеет значение порядок?
Переведено автоматически
Ответ 1
Если вы хотите просто получить доступ к глобальной переменной, вы просто используете ее имя. Однако, чтобы изменить ее значение, вам нужно использовать global
ключевое слово.
Например.
global someVar
someVar = 55
Это изменило бы значение глобальной переменной на 55. В противном случае она просто присвоила бы 55 локальной переменной.
Порядок списков определений функций не имеет значения (при условии, что они каким-либо образом не ссылаются друг на друга), имеет значение порядок их вызова.
Ответ 2
В области 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
, он создает локальную копию, поскольку он присваивает значение.
Путаница здесь в том, почему вы не должны использовать глобальные переменные.
Ответ 3
Вы можете напрямую обращаться к глобальной переменной внутри функции. Если вы хотите изменить значение этой глобальной переменной, используйте "global variable_name" . Смотрите следующий пример:
var = 1
def global_var_change():
global var
var = "value changed"
global_var_change() #call the function for changes
print var
Вообще говоря, это не очень хорошая практика программирования. Из-за нарушения логики пространства имен код может стать трудным для понимания и отладки.
Ответ 4
Как отмечали другие, вам нужно объявить переменную 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