Python使用一个简单的启发式方法来决定应该从哪个范围加载变量，在本地和全局之间。如果变量名出现在赋值的左侧，但未声明为全局变量，则假定它是局部变量。如果它没有出现在赋值的左侧，则假定它是全局的。

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

看看baz（出现在foo（）赋值的左侧）是如何成为唯一的LOAD_FAST变量的。

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

与不同平台/环境上的多处理相关的全局变量因为一边是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

实际上，您并没有将全局变量存储在本地变量中，只是创建了对原始全局引用引用的同一对象的本地引用。请记住，Python中的几乎所有内容都是引用对象的名称，在通常的操作中不会复制任何内容。

如果您不必显式指定标识符何时引用预定义的全局变量，那么您可能必须显式指定何时标识符是新的局部变量（例如，使用JavaScript中的“var”命令）。由于在任何严肃和非平凡的系统中，局部变量比全局变量更常见，因此Python的系统在大多数情况下更有意义。

你可能有一种语言试图猜测，如果存在的话使用一个全局变量，如果不存在的话创建一个局部变量。然而，这很容易出错。例如，导入另一个模块可能会无意中引入一个同名的全局变量，从而改变程序的行为。

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

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

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

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

类似此代码：

myVar = 12

def myFunc():
  myVar += 12

Key:

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

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

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

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

然后文档中有100个。