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

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

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）。

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

有两种方法可以将变量声明为全局变量：

1.在函数内部分配变量并使用全局线

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 

2.分配变量外部函数：

global_variable_2 = 2

现在我们可以在其他函数中使用这些声明的全局变量：

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 
global_variable_2 = 2

def print_variables():
    print(global_variable_1)
    print(global_variable_2)
print_variables() # prints 1 & 2

注1：

如果要更改另一个函数（如update_variables（））中的全局变量，则应在分配变量之前在该函数中使用全局行：

global_variable_1 = 1
global_variable_2 = 2

def update_variables():
    global global_variable_1
    global_variable_1 = 11
    global_variable_2 = 12 # will update just locally for this function

update_variables()
print(global_variable_1) # prints 11
print(global_variable_2) # prints 2

注2：

在函数内部不使用全局行时，列表和字典变量的注释1有一个例外：

# declaring some global variables
variable = 'peter'
list_variable_1 = ['a','b']
list_variable_2 = ['c','d']

def update_global_variables():
    """without using global line"""
    variable = 'PETER' # won't update in global scope
    list_variable_1 = ['A','B'] # won't update in global scope
    list_variable_2[0] = 'C' # updated in global scope surprisingly this way
    list_variable_2[1] = 'D' # updated in global scope surprisingly this way

update_global_variables()

print('variable is: %s'%variable) # prints peter
print('list_variable_1 is: %s'%list_variable_1) # prints ['a', 'b']
print('list_variable_2 is: %s'%list_variable_2) # prints ['C', 'D']

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

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

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

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

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

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

文件initval.py：

Stocksin = 300
Prices = []

文件getstocks.py：

import initval as iv

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


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