python | 一文看懂Python闭包机制与变量作用域规则

本文来源公众号“python”，仅用于学术分享，侵权删，干货满满。

原文链接：一文看懂Python闭包机制与变量作用域规则

在Python编程中，闭包和变量作用域是两个重要的概念。闭包（Closure）是一种函数对象，它能够记住并捕获创建时的环境变量，因此即使在函数调用结束后，闭包也能访问这些变量。闭包与变量作用域密切相关，而变量作用域则决定了变量在代码中的可见性和生命周期。理解闭包和变量作用域可以编写更灵活、更模块化的代码，同时也能提高对Python内部机制的理解。

变量作用域

在Python中，变量作用域是指变量在代码中的可访问范围。

1. Local（局部作用域）：定义在函数内部的变量，仅在函数内部可见。

2. Enclosing（闭包作用域）：嵌套函数的外层函数作用域。

3. Global（全局作用域）：模块级别的变量，在整个模块中可见。

4. Built-in（内置作用域）：Python的内置名称空间，包含len、range等Python内置函数。

这四种作用域遵循LEGB（Local、Enclosing、Global、Built-in）规则，即在访问变量时，Python会按此顺序依次查找变量。

LEGB作用域规则

以下代码展示了LEGB作用域查找规则的具体应用：

x = "global"

def outer():
    x = "enclosing"

    def inner():
        x = "local"
        print(x)

    inner()

outer()  # 输出：local
print(x)  # 输出：global

在这个示例中，Python首先在inner()函数的局部作用域中查找x，找到x = "local"并打印；如果没有找到，则会继续在outer()的闭包作用域、全局作用域和内置作用域中查找。

什么是闭包

闭包是指在一个函数内部定义了一个嵌套函数，且这个嵌套函数引用了外层函数的变量。当外层函数执行结束后，这些引用的变量依然存在于嵌套函数的环境中，即使外层函数的作用域不再存在，嵌套函数仍然可以访问这些变量。

闭包的特点是“函数对象+环境变量”，环境变量是函数定义时捕获的变量，它使得函数可以在其定义环境之外的地方使用。

闭包的构成条件

1. 嵌套函数：函数内部定义了另一个函数。

2. 外层函数返回嵌套函数：外层函数返回嵌套函数，以便在外部调用。

3. 嵌套函数使用了外层函数的变量：嵌套函数引用了外层函数中的变量，使得这些变量在外层函数作用域结束后仍然有效。

下面的代码展示了一个闭包的基本示例：

def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

# 创建闭包
closure = outer_func(10)
print(closure(5))  # 输出：15

在这个例子中，outer_func返回了一个inner_func闭包。即使outer_func的执行结束，但inner_func仍然能够访问到outer_func中的变量x，从而成功返回x + y的结果。

闭包的实际应用

1. 实现带状态的函数

闭包可以保存变量的状态，因此常用于实现带状态的函数。

以下代码展示了如何使用闭包实现一个计数器函数：

def counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment

# 创建计数器闭包
counter_func = counter()
print(counter_func())  # 输出：1
print(counter_func())  # 输出：2
print(counter_func())  # 输出：3

在这个示例中，counter函数返回了increment闭包。每次调用increment时，闭包会更新count变量，从而实现计数器功能。通过使用nonlocal关键字，我们可以在嵌套函数中修改外层函数的变量。

2. 延迟计算

闭包也可以用于延迟计算，即在需要时再执行特定操作。

以下代码展示了一个简单的延迟计算示例：

def lazy_multiply(x):
    def multiply(y):
        return x * y
    return multiply

# 创建延迟计算闭包
double = lazy_multiply(2)
triple = lazy_multiply(3)
print(double(5))  # 输出：10
print(triple(5))  # 输出：15

在这个例子中，lazy_multiply返回了一个multiply闭包，使得我们可以创建不同的乘法操作对象，如double和triple，从而在需要时执行乘法运算。

3. 封装对象行为

闭包还可以用于封装对象的行为，使得数据和操作的访问仅限于闭包内部。

以下代码展示了一个基于闭包实现的简单账户系统：

def create_account(balance):
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance

    def withdraw(amount):
        nonlocal balance
        if balance >= amount:
            balance -= amount
            return balance
        else:
            return "余额不足"

    return deposit, withdraw

# 创建账户闭包
deposit_func, withdraw_func = create_account(100)
print(deposit_func(50))     # 输出：150
print(withdraw_func(30))    # 输出：120
print(withdraw_func(200))   # 输出：余额不足

在这个示例中，create_account返回两个闭包deposit和withdraw，分别用于存款和取款操作。通过闭包，实现了对账户余额的封装，确保了余额变量的私密性。

变量作用域与闭包

在闭包中，变量作用域会影响变量的查找和修改行为。Python中，嵌套函数对外层变量的访问遵循LEGB规则，但如果想在闭包中修改外层作用域的变量，需要使用nonlocal关键字。如果闭包想要修改全局变量，需要使用global关键字。

nonlocal关键字

在闭包中，nonlocal关键字用于声明外层非全局作用域的变量，使得闭包可以修改它的值。

def outer():
    x = 10

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

    return inner

# 创建闭包
increment = outer()
print(increment())  # 输出：11
print(increment())  # 输出：12

在这个示例中，nonlocal x允许inner闭包修改outer函数中的x变量。否则，x将被视为inner函数的局部变量，无法修改外层作用域的值。

闭包与lambda表达式

闭包不仅可以用在普通函数中，还可以与lambda表达式结合使用。lambda表达式通常用于创建简洁的闭包，使代码更加简洁和高效。

lambda闭包示例

以下代码展示了一个使用lambda表达式实现的闭包示例：

def power(n):
    return lambda x: x ** n

# 创建平方和立方闭包
square = power(2)
cube = power(3)
print(square(4))  # 输出：16
print(cube(4))    # 输出：64

在这个例子中，power函数返回了一个lambda闭包，使得我们可以生成不同次幂的计算函数，如平方和立方函数。这种方式使代码更为简洁。

闭包的优缺点

优点	缺点
允许函数拥有私有变量，提高封装性	使用不当可能导致代码难以理解
可以创建带状态的函数	若闭包中包含大量数据，可能增加内存消耗
提高函数的灵活性和可重用性	不易调试，可能出现意料之外的错误

总结

闭包和变量作用域是Python编程中非常重要的概念。闭包是一种函数对象，即使在外层函数执行完毕后，嵌套函数依然能够访问其创建时的环境变量，能够实现带状态的函数和数据的封装。变量作用域决定了变量在不同范围内的可访问性和生命周期，遵循LEGB规则，即局部、闭包、全局和内置作用域的顺序。理解闭包与作用域的关系，不仅能提高代码的封装性和复用性，还能帮助编写更简洁、逻辑清晰的代码。掌握这些特性可以在编写带状态的函数、延迟计算、以及实现封装时更加得心应手。

THE END !

文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。