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

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]

如果您有一个同名的局部变量，您可能需要使用globals（）函数。

globals()['your_global_var'] = 42

除了已经存在的答案之外，为了使这一问题更加令人困惑：

在Python中，仅在函数内部引用的变量是隐式全局。如果在任何地方为变量分配了新值在函数体中，假设它是局部的。如果变量如果在函数中分配了一个新值，则变量为隐式本地，您需要将其显式声明为“全局”。虽然一开始有点令人惊讶，但片刻的思考解释了这一方面，要求全局分配变量提供了防止意外的副作用。另一方面，如果全球对于所有全局引用都是必需的时间您必须将对内置函数或导入模块的组件。这种混乱会破坏全球宣言对识别副作用。

来源：Python中局部和全局变量的规则是什么？。

您需要在每个要使用的函数中引用全局变量。

如下：

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""

引用要显示更改的类命名空间。

在本例中，runner使用文件config中的max。我希望我的测试在跑步者使用时更改max的值。

main/config.py

max = 15000

主/运行程序.py

from main import config
def check_threads():
    return max < thread_count 

测试/runner_test.py

from main import runner                # <----- 1. add file
from main.runner import check_threads
class RunnerTest(unittest):
   def test_threads(self):
       runner.max = 0                  # <----- 2. set global 
       check_threads()

作为附加组件，使用一个文件来包含所有本地声明的全局变量，然后导入为：

文件initval.py：

Stocksin = 300
Prices = []

文件getstocks.py：

import initval as iv

def getmystocks(): 
    iv.Stocksin = getstockcount()


def getmycharts():
    for ic in range(iv.Stocksin):