Python函数全局variables？
所以我知道我应该首先避免使用全局variables，因为这样的混乱，但是如果我使用它们，下面是一个有效的方法来使用它们吗？ （我试图调用在一个单独的函数中创build的variables的全局副本。）
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的全局副本相同的值？ 定义后调用函数时，命令是否重要？
如果你只想访问一个全局variables，你只需要使用它的名字。 但是要更改其值，您需要使用global关键字。
例如
global someVar someVar = 55
这会将全局variables的值更改为55，否则只会将55赋值给局部variables。
函数定义列表的顺序并不重要（假设它们不以某种方式彼此引用），它们被调用的顺序就是这样。
在一个Python作用域内， 除非该variables在函数前面被声明为引用具有关键字global的全局作用域variables， 否则对该variables范围内尚未声明的variables的任何赋值都会创build一个新的局部variables。
让我们看看你的伪代码的修改版本，看看会发生什么：
# 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的variables来重写所有的x_local并且它的工作原理是一样的。
这个顺序只和你的函数执行改变全局x值的操作的顺序有关。 因此，在我们的例子中，顺序并不重要，因为func_A调用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，尽pipe不调用global ，即使create_locally也不global使用，它会创build一个本地副本，因为它正在分配一个值。
这里的困惑是为什么你不应该使用全局variables。
正如其他人所指出的，当你希望函数能够修改全局variables时，你需要在函数中声明一个variables全局variables。 如果你只想访问它，那么你不需要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
这里有一个案例，使我把全局作为参数的默认值。
globVar = None # initialize value of global variable def func(param = globVar): # use globVar as default value for param print 'param =', param, 'globVar =', globVar # display values def test(): global globVar globVar = 42 # change value of global func() test() ========= output: param = None, globVar = 42
我曾经期望参数值为42.惊喜。 Python 2.7在首次分析函数func时计算了globVar的值。 更改globVar的值不会影响分配给param的默认值。 延迟评估，如下所示，按我需要的那样工作。
def func(param = eval('globVar')): # this seems to work print 'param =', param, 'globVar =', globVar # display values
或者，如果你想要安全，
def func(param = None)): if param == None: param = globVar print 'param =', param, 'globVar =', globVar # display values
当您希望更改分配给全局variables的值时，必须使用global声明。
您不需要它从全局variables读取。 请注意，调用一个对象的方法（即使它改变了该对象内的数据）并不会改变该对象的variables的值（缺lessreflection魔法）。
您可以直接访问函数内的全局variables。 如果要更改该全局variables的值，请使用“全局variables名称”。 看下面的例子：
var = 1 def global_var_change(): global var var = "value changed" global_var_change() #call the function for changes print var
一般来说，这不是一个好的编程习惯。 通过打破命名空间逻辑，代码可能变得难以理解和debugging。
