Python函数全局变量？

Question

我知道由于这样的混淆，我应该首先避免使用全局变量，但是如果我要使用它们，以下是使用它们的有效方法吗？（我正在尝试调用在单独的函数中创建的变量的全局副本。）

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是否与func_a使用和修改的x的全局副本具有相同的值？定义后调用函数时，顺序重要吗？

Answer 1

正如其他人所指出的，当您希望函数能够修改全局变量时，您需要在函数中声明该变量全局。如果您只想访问它，则不需要全局。

更详细地说，“修改”的意思是：如果您想重新绑定全局名称以使其指向不同的对象，则必须在函数中声明名称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

Answer 2

在Python范围内，对尚未在该范围内声明的变量的任何赋值都会创建一个新的局部变量，除非该变量在函数中被声明为引用具有关键字< code>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

事实上，您可以使用名为x_local的变量重写所有func_B，并且它的工作方式相同。

只有在函数执行改变全局x值的操作时，顺序才重要。因此，在我们的示例中，顺序并不重要，因为< code>func_B调用< code>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，它会创建一个本地副本，因为它正在分配一个值。

这里的困惑是为什么你不应该使用全局变量。

Answer 3

如果您想简单地访问全局变量，只需使用其名称即可。但是，要更改其值，需要使用＜code＞全局

例如。

global someVar
someVar = 55

这会将全局变量的值更改为55。否则它只会将55分配给局部变量。

函数定义列表的顺序并不重要（假设它们没有以某种方式相互引用），调用它们的顺序是重要的。