如何在函数中创建或使用全局变量?

如何在其他函数中使用一个函数中定义的全局变量?


未能在适当的地方使用全局关键字通常会导致UnboundLocalError。在第一次使用后重新分配局部变量时,UnboundLocalError中解释了这方面的精确规则。一般来说,当寻求解释时,请将其他问题作为该问题的副本,当某人只需要知道全局关键字时,请关闭该问题。


当前回答

对于并行执行,如果您不了解正在发生的情况,全局变量可能会导致意外的结果。下面是在多处理中使用全局变量的示例。我们可以清楚地看到,每个过程都使用自己的变量副本:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

输出:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

其他回答

global_var = 10  # will be considered as a global variable


def func_1():
    global global_var  # access variable using variable keyword
    global_var += 1


def func_2():
    global global_var
    global_var *= 2
    print(f"func_2: {global_var}")


func_1()
func_2()
print("Global scope:", global_var) # will print 22

说明:

globalvar是一个全局变量,所有函数和类都可以访问该变量。

func_1()使用关键字global访问该全局变量,该关键字指向写入全局范围的变量。如果我没有写全局关键字,func_1内的变量global_var被认为是一个局部变量,只能在函数内使用。然后在func_1内,我将全局变量递增1。

在func_2()中也发生了同样的情况。

调用func_1和func_2后,您将看到global_var已更改

如果要访问全局变量,只需在函数中添加全局关键字前任:global_var=“是”

def someFunc():
   global global_var;
   print(nam_of_var)

如果我正确理解了您的情况,那么您看到的是Python如何处理本地(函数)和全局(模块)命名空间的结果。

假设你有这样一个模块:

# sample.py
_my_global = 5

def func1():
    _my_global = 42

def func2():
    print _my_global

func1()
func2()

您可能希望它打印42,但实际上它打印5。如上所述,如果向func1()添加一个“全局”声明,那么func2()将打印42。

def func1():
    global _my_global 
    _my_global = 42

这里发生的情况是,Python假设在函数中的任何地方,任何分配给的名称都是该函数的本地名称,除非另有明确说明。如果它只是从一个名称中读取,并且该名称在本地不存在,那么它将尝试在任何包含范围(例如模块的全局范围)中查找该名称。

因此,当将42指定给名称_my_global时,Python将创建一个局部变量,该变量将覆盖同名的全局变量。当func1()返回时,该local超出范围并被垃圾收集;同时,func2()只能看到(未修改的)全局名称。请注意,这个命名空间决定发生在编译时,而不是在运行时——如果在赋值之前读取func1()内部的_my_global值,则会得到UnboundLocalError,因为Python已经决定它必须是一个本地变量,但它还没有与之关联的任何值。但通过使用“global”语句,您告诉Python应该在其他地方查找名称,而不是在本地分配。

(我认为,这种行为主要源于对本地名称空间的优化——如果没有这种行为,Python的VM每次在函数内部分配新名称时都需要执行至少三次名称查找(以确保该名称在模块/内置级别上不存在),这将大大降低非常常见的操作速度。)

如果要在函数中引用全局变量,可以使用global关键字声明哪些变量是全局变量。您不必在所有情况下都使用它(正如这里有人错误地宣称的那样)-如果表达式中引用的名称无法在定义该函数的函数的局部作用域中找到,则会在全局变量中查找该名称。

但是,如果您分配给函数中未声明为全局的新变量,则它将隐式声明为局部变量,并且它可能会覆盖同名的任何现有全局变量。

此外,全局变量是有用的,与一些OOP狂热者的说法相反——特别是对于较小的脚本,OOP是过度的。

类似此代码:

myVar = 12

def myFunc():
  myVar += 12

Key:

如果在字符串外部声明变量,它将变为全局变量。

如果在字符串中声明变量,它将变为本地变量。

如果要在字符串中声明全局变量,请在要声明的变量之前使用关键字global:

myVar = 124
def myFunc():
  global myVar2
  myVar2 = 100
myFunc()
print(myVar2)

然后文档中有100个。