引用要在其中显示更改的类名称空间。

在此示例中，Runner正在使用文件配置中的max。我希望我的测试在跑步者使用它时更改max的值。

main / config.py

max = 15000

main / runner.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()

写入全局数组的显式元素显然不需要全局声明，尽管对其进行“批发”写入确实具有该要求：

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

我添加此内容是因为我在其他任何答案中都没有看到它，这对于那些在类似问题上苦苦挣扎的人可能很有用。该globals()函数返回一个可变的全局符号字典，您可以在其中“神奇地”使数据可用于其余代码。例如：

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

和

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

只会让您将变量转储到全局名称空间中或从中加载到全局名称空间中。超级方便，没有混乱，没有大惊小怪。可以肯定的是，只有Python 3。

接下来，作为附加，使用文件包含所有在本地声明的所有全局变量，然后import as：

文件initval.py：

Stocksin = 300
Prices = []

文件getstocks.py：

import initval as iv

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


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

您实际上并没有将全局变量存储在局部变量中，而只是创建了对原始全局引用所引用的同一对象的局部引用。请记住，Python中的几乎所有东西都是一个引用对象的名称，在常规操作中什么也不会被复制。

如果不必显式指定标识符何时引用预定义的全局变量，则可能必须显式地指定标识符何时是新的局部变量（例如，使用诸如“ var”命令之类的东西）在JavaScript中看到）。由于局部变量在任何严重且不平凡的系统中都比全局变量更普遍，因此Python的系统在大多数情况下更有意义。

您可能有一种尝试进行猜测的语言，如果存在则使用全局变量，如果不存在则创建本地变量。但是，这很容易出错。例如，导入另一个模块可能会无意中通过该名称引入全局变量，从而改变程序的行为。

试试这个：

def x1():
    global x
    x = 6

def x2():
    global x
    x = x+1
    print x

x = 5
x1()
x2()  # output --> 7

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

如下：

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]
"""

您所说的是使用这样的方法：

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

但是更好的方法是像这样使用全局变量：

globavar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

两者给出相同的输出。

In addition to already existing answers and to make this more confusing:

In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as ‘global’.

尽管起初有些令人惊讶，但片刻的考虑可以解释这一点。一方面，要求全局分配变量可防止意外副作用。另一方面，如果所有全局引用都需要全局，那么您将一直使用全局。您必须将对内置函数或导入模块的组件的每个引用声明为全局引用。这种混乱将破坏全球宣言对确定副作用的有用性。

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

如果要在函数中引用全局变量，则可以使用global关键字声明哪些变量是全局变量。您不必在所有情况下都使用它（因为这里的人不正确地声称）-如果在本地作用域或定义此功能的函数的作用域中找不到表达式中引用的名称，则在全局范围内查找该名称变量。

但是，如果在函数中分配了一个未声明为全局变量的新变量，则该变量将隐式声明为局部变量，并且可能使任何现有的具有相同名称的全局变量都被遮盖。

同样，全局变量是有用的，这与某些OOP狂热者相反，特别是对于较小的脚本（OOP过分杀伤）更是如此。

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变量。