Python中global和nonlocal关键字的妙用：变量管理技巧

大家好，我是涛哥，本文内容来自 涛哥聊Python ，转载请标原创。

在 Python 中编写函数时，经常会遇到需要在函数内部访问和修改外部变量的情况。在这种情况下，我们可以使用 global 和 nonlocal 关键字来声明变量的作用域，以便正确地访问和修改这些变量。本文将深入探讨 global 和 nonlocal 的用法，包括详细的示例代码和实际应用场景。

global 关键字

在 Python 中，global 关键字用于在函数内部声明全局变量。当在函数内部使用一个变量，并且希望该变量在函数外部也可见和修改时，就需要使用 global 关键字。

示例代码：

x = 10

def increment_global():
    global x
    x += 1
    print("函数内部 x 的值:", x)

increment_global()
print("函数外部 x 的值:", x)

在上面的示例中，使用 global 关键字声明了变量 x 是全局变量，因此在 increment_global 函数内部可以对其进行修改。

nonlocal 关键字

与 global 关键字不同，nonlocal 关键字用于在嵌套函数中声明外部嵌套作用域中的变量。当在一个函数内部定义了另一个函数，并且希望内部函数可以访问外部函数的变量时，就需要使用 nonlocal 关键字。

示例代码：

def outer_function():
    y = 20

    def inner_function():
        nonlocal y
        y += 1
        print("内部函数 y 的值:", y)

    inner_function()
    print("外部函数 y 的值:", y)

outer_function()

在上面的示例中，使用 nonlocal 关键字声明了变量 y 是外部函数 outer_function 中的变量，因此在 inner_function 内部可以对其进行修改。

实际应用场景

1. 在函数内部修改全局变量

有时候需要在函数内部修改全局变量，例如计数器等应用场景。

count = 0

def increment_counter():
    global count
    count += 1
    print("当前计数器值:", count)

increment_counter()
increment_counter()

2. 在嵌套函数中访问外部函数的变量

当在一个函数内部定义了另一个函数，并且需要内部函数访问外部函数的变量时，可以使用 nonlocal 关键字。

def outer_function():
    result = 0

    def inner_function():
        nonlocal result
        result += 10
        print("内部函数计算结果:", result)

    inner_function()
    print("外部函数计算结果:", result)

outer_function()

3. 在闭包中使用外部变量

闭包是一种特殊的函数，可以访问其外部作用域中定义的变量。使用 nonlocal 关键字可以在闭包中修改外部变量的值。

def outer():
    x = 10

    def inner():
        nonlocal x
        x += 5
        return x

    return inner

closure = outer()
print("闭包中的值:", closure())

示例代码

1. 使用 global 关键字管理全局变量

global_var = 100

def modify_global():
    global global_var
    global_var += 50

modify_global()
print("修改后的全局变量值:", global_var)

上述代码中，声明了一个全局变量 global_var，然后在函数内部使用 global 关键字来修改它的值，从而实现对全局变量的管理。

2. 使用 nonlocal 关键字访问外部函数的变量

def outer_function():
    outer_var = 10

    def inner_function():
        nonlocal outer_var
        outer_var += 5
        print("内部函数中的外部变量值:", outer_var)

    inner_function()
    print("外部函数中的外部变量值:", outer_var)

outer_function()

在这个示例中，定义了一个外部函数 outer_function，其中包含一个变量 outer_var。在内部函数 inner_function 中，使用 nonlocal 关键字访问并修改了外部函数中的变量 outer_var，并打印了修改后的值。

3. 使用 global 和 nonlocal 关键字的组合

global_var = 100

def outer_function():
    nonlocal_var = 50

    def inner_function():
        global global_var
        nonlocal nonlocal_var

        global_var += 10
        nonlocal_var += 20

        print("全局变量值:", global_var)
        print("外部函数中的非局部变量值:", nonlocal_var)

    inner_function()
    print("全局变量值（外部函数中修改后）:", global_var)
    print("外部函数中的非局部变量值（外部函数中修改后）:", nonlocal_var)

outer_function()

这个示例演示了在嵌套函数中同时使用 global 和 nonlocal 关键字的情况。在内部函数 inner_function 中修改了全局变量 global_var 和外部函数中的非局部变量 nonlocal_var，并打印了它们的值。同时，在外部函数中也打印了这些变量的修改后的值。

总结

Python 中的 global 和 nonlocal 关键字在变量作用域和值传递方面发挥着重要作用。global 关键字用于在函数内部声明全局变量，使得函数内部可以访问和修改全局变量的值。而 nonlocal 关键字则用于在嵌套函数中声明外部嵌套作用域中的变量，使得内部函数可以访问和修改外部函数中的变量。