`闭包`与`非局部变量`：`nonlocal`关键字的`作用域`解析与实际应用。

闭包与非局部变量：nonlocal关键字的作用域解析与实际应用

各位同学，大家好！今天我们来深入探讨Python中一个比较高级但又非常重要的概念：闭包以及与之紧密相关的非局部变量。我们将重点关注nonlocal关键字的作用域，并通过大量的实例来理解它的实际应用。

什么是闭包？

在开始讨论nonlocal之前，我们首先要理解什么是闭包。简单来说，闭包是指函数与其周围状态（词法环境）的捆绑。更具体地说，一个闭包是由一个函数和其所能访问的自由变量（在定义函数的词法作用域内未绑定到特定对象的变量）组成的。

让我们看一个简单的例子：

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

closure = outer_function(10)
print(closure(5))  # 输出 15

在这个例子中，inner_function是定义在outer_function内部的函数。inner_function可以访问outer_function的变量x。当outer_function返回inner_function时，inner_function就形成了一个闭包。即使outer_function已经执行完毕，闭包仍然可以访问并使用x的值。

关键点在于：

• 嵌套函数: 闭包通常涉及一个函数定义在另一个函数内部。
• 外部函数变量访问: 内部函数可以访问外部函数的变量。
• 状态保持: 即使外部函数执行完毕，闭包仍然可以访问和使用外部函数的状态。

变量作用域：LEGB规则

理解闭包的关键在于理解Python的作用域规则。Python使用LEGB规则来确定变量的查找顺序：

• L (Local): 当前函数的作用域。
• E (Enclosing function locals): 包含当前函数的外部函数的作用域。
• G (Global): 全局作用域。
• B (Built-in): 内置作用域。

当在一个函数中引用一个变量时，Python会按照LEGB的顺序依次查找，直到找到该变量为止。

在上面的闭包例子中，y是在inner_function的局部作用域中定义的，而x是在outer_function的封闭作用域中定义的。因此，inner_function可以通过E规则访问x。

nonlocal关键字的作用

nonlocal关键字允许我们在内部函数中修改外部函数的变量。如果没有nonlocal关键字，内部函数只能访问外部函数的变量，而不能修改它们。

考虑以下例子：

def outer_function():
    x = 10
    def inner_function():
        x = 20  # 创建一个新的局部变量 x
        print("Inner:", x)
    inner_function()
    print("Outer:", x)

outer_function()

输出：

Inner: 20
Outer: 10

在这个例子中，inner_function中的x = 20创建了一个新的局部变量x，它与outer_function中的x是不同的变量。因此，outer_function中的x的值没有被修改。

现在，让我们使用nonlocal关键字：

def outer_function():
    x = 10
    def inner_function():
        nonlocal x  # 声明 x 是外部函数的作用域的变量
        x = 20
        print("Inner:", x)
    inner_function()
    print("Outer:", x)

outer_function()

输出：

Inner: 20
Outer: 20

在这个例子中，nonlocal x告诉Python，x不是inner_function的局部变量，而是outer_function的变量。因此，inner_function中的x = 20会修改outer_function中的x的值。

总结一下 nonlocal 的作用:

• nonlocal 关键字用于在嵌套函数中引用和修改外部函数的变量。
• 它使得内部函数可以改变封闭作用域中的变量，而不是创建新的局部变量。
• 如果没有 nonlocal，内部函数只能读取外部函数变量，不能修改。

nonlocal 的使用规则

• nonlocal 关键字只能用于嵌套函数中。
• nonlocal 声明的变量必须存在于封闭函数的作用域中。
• nonlocal 不能用于全局作用域中的变量。

例如，以下代码会引发 SyntaxError：

x = 10
def outer_function():
    def inner_function():
        nonlocal x  # SyntaxError: no binding for nonlocal 'x' found
        x = 20
    inner_function()

outer_function()

这是因为 x 是全局变量，而不是封闭函数的变量。

global 关键字与 nonlocal 关键字的区别

global 关键字用于在函数中引用和修改全局变量。nonlocal 关键字用于在嵌套函数中引用和修改外部函数的变量。

特性	global	nonlocal
作用域	全局作用域	封闭函数作用域
使用场景	在函数中访问和修改全局变量	在嵌套函数中访问和修改外部函数变量
适用范围	任何函数	仅限嵌套函数
声明变量要求	全局变量可以不存在，如果不存在，就创建一个	封闭函数中必须存在声明的变量

实际应用：计数器

闭包和nonlocal关键字的一个常见应用是创建计数器。

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

my_counter = make_counter()
print(my_counter())  # 输出 1
print(my_counter())  # 输出 2
print(my_counter())  # 输出 3

在这个例子中，make_counter函数返回一个闭包counter。counter函数使用nonlocal关键字来访问和修改make_counter函数中的count变量。每次调用counter函数时，count的值都会递增。

实际应用：状态保持

闭包和nonlocal关键字还可以用于在函数调用之间保持状态。

def average():
    total = 0
    count = 0
    def inner(number):
        nonlocal total, count
        total += number
        count += 1
        return total / count
    return inner

avg = average()
print(avg(10))  # 输出 10.0
print(avg(20))  # 输出 15.0
print(avg(30))  # 输出 20.0

在这个例子中，average函数返回一个闭包inner。inner函数使用nonlocal关键字来访问和修改average函数中的total和count变量。每次调用inner函数时，它会将新的数字添加到total中，并将count的值递增，然后返回平均值。

实际应用：装饰器

闭包和nonlocal关键字在装饰器中也经常使用。装饰器是一种修改函数行为的方法，而无需修改函数本身。

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"Function {func.__name__} took {execution_time:.4f} seconds to execute.")
        return result
    return wrapper

@timer
def my_function(n):
    time.sleep(n)

my_function(2)

在这个例子中，timer函数是一个装饰器，它接受一个函数作为参数，并返回一个新的函数wrapper。wrapper函数在调用原始函数之前和之后记录时间，并打印执行时间。wrapper函数是一个闭包，它可以访问timer函数的func变量。

现在，让我们使用nonlocal关键字来创建一个更复杂的装饰器，它可以记录函数的调用次数。

def call_counter(func):
    count = 0
    def wrapper(*args, **kwargs):
        nonlocal count
        count += 1
        print(f"Function {func.__name__} has been called {count} times.")
        return func(*args, **kwargs)
    return wrapper

@call_counter
def my_function():
    print("Hello, world!")

my_function()
my_function()
my_function()

输出：

Function my_function has been called 1 times.
Hello, world!
Function my_function has been called 2 times.
Hello, world!
Function my_function has been called 3 times.
Hello, world!

在这个例子中，call_counter函数是一个装饰器，它接受一个函数作为参数，并返回一个新的函数wrapper。wrapper函数使用nonlocal关键字来访问和修改call_counter函数中的count变量。每次调用wrapper函数时，count的值都会递增，并打印函数的调用次数。

避免陷阱：理解作用域

在使用nonlocal关键字时，需要特别注意作用域的问题。错误地使用nonlocal关键字可能会导致意想不到的结果。

例如，以下代码可能会导致错误：

def outer_function():
    def inner_function():
        nonlocal x  # NameError: free variable 'x' referenced before assignment in enclosing scope
        x = 20
        print("Inner:", x)
    inner_function()

outer_function()

在这个例子中，x在outer_function中没有被定义，因此inner_function中的nonlocal x会导致NameError。

总结 nonlocal 的要点

关键点	描述
定义	允许在嵌套函数中修改外部函数的变量。
使用场景	创建计数器、状态保持、装饰器等。
作用域	只能用于嵌套函数中，声明的变量必须存在于封闭函数的作用域中，不能用于全局作用域。
与global的区别	global用于全局变量，nonlocal用于封闭函数变量。
注意事项	需要特别注意作用域的问题，错误地使用nonlocal关键字可能会导致意想不到的结果，例如NameError。

最佳实践建议

• 清晰地命名变量： 使用有意义的变量名，以提高代码的可读性。
• 避免过度使用： 只有在必要时才使用nonlocal关键字。过度使用可能会使代码难以理解和维护。
• 仔细考虑作用域： 在使用nonlocal关键字之前，仔细考虑变量的作用域，确保它是正确的。
• 编写单元测试： 编写单元测试可以帮助你发现和修复与nonlocal关键字相关的错误。
• 代码审查： 让其他开发人员审查你的代码，可以帮助你发现潜在的问题。

深入理解闭包与 nonlocal

通过以上讲解和示例，我们深入了解了闭包的概念，nonlocal 关键字的作用，以及它们在实际应用中的价值。理解闭包和nonlocal关键字对于编写更高级、更灵活的Python代码至关重要。希望大家在实际编程中能够灵活运用这些知识，编写出高质量的代码。