Python function global variables?
我知道我应该首先避免使用全局变量，因为这样的混淆，但是如果我要使用它们，下面的方法是否有效？(我试图调用在单独函数中创建的变量的全局副本。)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | 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() |
第二个函数使用的
型
如果只想访问一个全局变量，只需使用它的名称。但是，要更改其值，需要使用
例如。
1 2 | global someVar someVar = 55 |
这会将全局变量的值更改为55。否则它只将55赋给局部变量。
函数定义列表的顺序并不重要(假设它们没有以某种方式相互引用)，调用它们的顺序也不重要。
型
在python范围内，对尚未在该范围内声明的变量的任何赋值都将创建一个新的局部变量，除非该变量在函数前面声明为引用关键字
让我们看看您的伪代码的修改版本，看看会发生什么：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | # 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值的操作的顺序有关。因此，在我们的示例中，订单并不重要，因为
1 2 3 4 5 6 7 8 9 10 11 12 | 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'. |
。
注意，
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | 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. |
注意
这里的困惑是为什么不应该使用全局变量。
型
正如其他人所指出的，当您希望函数能够修改全局变量时，您需要在函数中声明一个变量
为了更详细地说明这一点，"modify"的意思是：如果要重新绑定全局名称，使其指向不同的对象，则必须在函数中声明
许多修改(变异)对象的操作不会将全局名称重新绑定到另一个对象，因此它们都是有效的，而不会在函数中声明名称
1 2 3 4 5 6 7 8 9 10 | 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 |
号
型
这里有一个例子让我明白了，使用全局作为参数的默认值。
1 2 3 4 5 6 7 8 9 10 11 12 13 | 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 |
。
我原以为param的值是42。惊喜。python 2.7在第一次解析函数func时评估了globalvar的值。更改globalvar的值不会影响分配给param的默认值。延迟评估，如下面所述，按我的需要工作。
1 2 | def func(param = eval('globVar')): # this seems to work print 'param =', param, 'globVar =', globVar # display values |
。
或者，如果你想安全，
1 2 3 4 | def func(param = None)): if param == None: param = globVar print 'param =', param, 'globVar =', globVar # display values |
型
您可以直接访问函数内的全局变量。如果要更改该全局变量的值，请使用"全局变量名称"。请参见以下示例：
1 2 3 4 5 6 | var = 1 def global_var_change(): global var var ="value changed" global_var_change() #call the function for changes print var |
。
一般来说，这不是一个好的编程实践。通过破坏名称空间逻辑，代码可能变得难以理解和调试。
型
当您希望更改分配给全局变量的值时，必须使用
您不需要它从全局变量中读取。请注意，对对象调用方法(即使它改变了该对象中的数据)不会改变持有该对象的变量的值(没有反射魔法)。