我补充了这一点，因为我在其他任何答案中都没有看到它，它可能对正在与类似问题作斗争的人有用。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

and

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

将只允许您将变量转储/加载到全局命名空间中。超级方便，没有麻烦，没有麻烦。很确定它只是Python 3。

写入全局数组的显式元素显然不需要全局声明，尽管“批发”写入它确实有这样的要求：

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

如果我在一个函数中创建一个全局变量，我如何在另一个函数上使用该变量？

我们可以使用以下函数创建全局：

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

编写函数实际上不会运行其代码。因此我们调用create_global_variable函数：

>>> create_global_variable()

使用全局变量而不进行修改

只要您不希望更改它指向的对象，就可以使用它：

例如

def use_global_variable():
    return global_variable + '!!!'

现在我们可以使用全局变量：

>>> use_global_variable()
'Foo!!!'

从函数内部修改全局变量

要将全局变量指向其他对象，需要再次使用全局关键字：

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

请注意，在编写此函数后，实际更改它的代码仍然没有运行：

>>> use_global_variable()
'Foo!!!'

因此，调用函数后：

>>> change_global_variable()

我们可以看到全局变量已经改变。global_variable名称现在指向“Bar”：

>>> use_global_variable()
'Bar!!!'

请注意，Python中的“全局”并不是真正的全局-它只是模块级的全局。因此，它只适用于在全局模块中编写的函数。函数会记住编写它们的模块，因此当它们导出到其他模块中时，它们仍然会查找创建它们的模块以查找全局变量。

同名的局部变量

如果创建同名的局部变量，它将覆盖全局变量：

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

但使用该错误命名的局部变量不会更改全局变量：

>>> use_global_variable()
'Bar!!!'

请注意，您应该避免使用与全局变量同名的局部变量，除非您确切地知道自己在做什么，并且有充分的理由这样做。我还没有遇到这样的原因。

我们在课堂上也有同样的行为

后续评论问道：

如果我想在类内的函数内创建一个全局变量，并想在另一个类内的另一个函数内使用该变量，该怎么办？

在这里，我演示了我们在方法中得到的行为与在正则函数中得到的相同：

class Foo:
    def foo(self):
        global global_variable
        global_variable = 'Foo'

class Bar:
    def bar(self):
        return global_variable + '!!!'

Foo().foo()

现在：

>>> Bar().bar()
'Foo!!!'

但我建议不要使用全局变量，而是使用类属性，以避免混淆模块名称空间。还要注意，我们这里不使用self参数-这些可以是类方法（如果从通常的cls参数中更改class属性，则很方便）或静态方法（没有self或cls）。

您可以在其他函数中使用全局变量，方法是在为其赋值的每个函数中将其声明为全局变量：

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

由于不清楚globvar=1是创建本地变量还是更改全局变量，Python默认创建本地变量，并使用全局关键字显式选择其他行为。

如果要在模块间共享全局变量，请参阅其他答案。

如果我正确理解了您的情况，那么您看到的是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每次在函数内部分配新名称时都需要执行至少三次名称查找（以确保该名称在模块/内置级别上不存在），这将大大降低非常常见的操作速度。）

您的意思是使用以下方法：

globvar = 5

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

f()  # Prints 5

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

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

两者的输出相同。