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

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

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

您可能需要探索名称空间的概念。在Python中，模块是全局数据的自然位置：

每个模块都有自己的专用符号表，该表被模块中定义的所有函数用作全局符号表。因此，模块的作者可以在模块中使用全局变量，而不用担心与用户的全局变量发生意外冲突。另一方面，如果你知道你在做什么，你可以用与引用它的函数相同的符号modname.itemname来触摸模块的全局变量。

这里描述了模块中全局变量的具体用法-如何在模块之间共享全局变量？，为完整起见，内容如下：

在单个程序中跨模块共享信息的规范方法是创建一个特殊的配置模块（通常称为config或cfg）。只需在应用程序的所有模块中导入配置模块；然后，模块变为可用的全局名称。因为每个模块只有一个实例，所以对模块对象所做的任何更改都会在任何地方反映出来。例如：

文件：config.py

x=0#“x”配置设置的默认值

文件：mod.py

import config
config.x = 1

文件：main.py

import config
import mod
print config.x

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已更改

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

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]

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

文件initval.py：

Stocksin = 300
Prices = []

文件getstocks.py：

import initval as iv

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


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

全局变量很好-除了多处理

与不同平台/环境上的多处理相关的全局变量因为一边是Windows/Mac OS，另一边是Linux，这很麻烦。

我将用一个简单的例子向你展示这一点，指出我前段时间遇到的一个问题。

如果你想了解为什么Windows/MacOs和Linux上的情况不同需要知道的是，启动新进程的默认机制。。。

Windows/MacOs是“种子”Linux是“fork”

它们在内存分配和初始化方面有所不同。。。（但我不想谈这个此处）。

让我们看看这个问题/例子。。。

import multiprocessing

counter = 0

def do(task_id):
    global counter
    counter +=1
    print(f'task {task_id}: counter = {counter}')

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=4)
    task_ids = list(range(4))
    pool.map(do, task_ids)

窗户

如果你在Windows上运行这个（我想也是在MacOS上），你会得到以下输出。。。

task 0: counter = 1
task 1: counter = 2
task 2: counter = 3
task 3: counter = 4

Linux系统

如果您在Linux上运行此程序，则会得到以下结果。

task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1