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是否具有与func_a使用和修改的x的全局副本相同的值？ 定义后调用函数时，命令是否重要？
如果你只想访问一个全局变量，你只需要使用它的名字。 但是，要更改其值，您需要使用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的功能，当你想要的功能，能够修改全局变量。 如果你只想访问它，那么你不需要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