Python 闭包（Closure）详解

在 Python 编程中，闭包（Closure）是一个非常重要的概念。它涉及到函数的嵌套定义以及如何利用函数内部的变量。理解闭包的工作原理对编写高效且优雅的代码至关重要。本文将带你全面了解 Python 中的闭包，解释其原理、用途以及一些常见的应用场景。

什么是闭包？

在 Python 中，闭包是指一个嵌套函数（即在一个函数内部定义的函数）可以访问其外部函数的变量，尽管外部函数的执行已经结束。这种访问外部函数变量的能力，构成了闭包的核心。

更具体地说，闭包的定义包含以下几个要素：

外部函数：这是定义内部函数的函数。
内部函数：被嵌套在外部函数中的函数，并且可以访问外部函数的局部变量。
自由变量：在内部函数中使用的、来自外部函数的变量。

简单来说，闭包允许内部函数“记住”并“访问”它定义时的外部环境，即使外部函数的作用域已经结束。

Python 中闭包的例子

下面通过一个简单的例子来理解闭包。

def outer(x):
    def inner(y):
        return x + y
    return inner

closure = outer(10)  # outer 函数返回了 inner 函数
print(closure(5))  # 输出 15

代码解析：

1.outer(x) 是外部函数，它接受一个参数 x。
2.inner(y) 是定义在 outer 内部的函数，它接受一个参数 y，并返回 x + y 的值。
3.outer(10) 调用外部函数并返回内部函数 inner。
4.变量 closure 存储了这个返回的函数，即 inner 函数。
5.当调用 closure(5) 时，实际上是调用了 inner(5)，而此时 x 的值为 10，因为 x 是 outer 函数中的自 由变量，inner 函数能够记住并访问它。

为什么 x 的值没有丢失？

尽管 outer(10) 已经执行完毕，闭包使得 inner 函数仍然能够访问 x。这就是闭包的特性：inner 函数“记住”了 x 的值，即使外部函数已经返回。

闭包的特点

  优点: 全局变量私有化，避免全局变量被随意污染
  缺点: 由于内部函数持续引用外部函数的值,所以会导致这一部分内存空间不被释放，一直占用内存,内存泄漏
 建议: 尽量避免使用闭包

闭包的应用场景

闭包在很多编程场景中非常有用，以下是一些常见的应用：

1. 函数工厂

闭包可以用来生成特定的函数，类似于“工厂”模式。例如，创建具有不同参数的加法器

def make_adder(x):
    def adder(y):
        return x + y
    return adder

add_5 = make_adder(5)
add_10 = make_adder(10)

print(add_5(3))  # 输出 8
print(add_10(3))  # 输出 13

在这个例子中，make_adder 是一个函数工厂，它根据传入的 x 生成一个加法器函数，add_5 和 add_10 都是闭包，可以在不同的上下文中使用。

2. 保持状态的函数

闭包可以保持状态，并允许在多个函数调用之间保留某些信息。

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

counter_fn = counter()
print(counter_fn())  # 输出 1
print(counter_fn())  # 输出 2
print(counter_fn())  # 输出 3

在这个例子中，counter 返回一个函数 increment，每次调用 increment 时都会更新并返回 count 的值。通过闭包，count 的状态在多次调用之间得以保留。

3. 延迟计算

闭包可以用于延迟计算或惰性求值，尤其在需要保存某些参数以供后续使用时非常有用。

def lazy_evaluation(x):
    def calculate():
        return x * x
    return calculate

lazy_square = lazy_evaluation(5)
print(lazy_square())  # 输出 25

在这个例子中，lazy_evaluation 返回一个闭包，这个闭包在之后被调用时计算 x 的平方。通过这种方式，x 的值不会立即被计算，而是延迟到 lazy_square() 被调用时才进行计算。

闭包与作用域

理解 Python 的作用域规则（LEGB 规则）对理解闭包至关重要。LEGB 代表：

   Local（局部作用域）
   Enclosing（嵌套函数作用域）
   Global（全局作用域）
   Built-in（内建作用域）

在闭包中，内部函数的自由变量（如 x）会首先在其本地作用域中查找，如果没有找到，它会向外层作用域查找，直到找到该变量或到达全局作用域。

例子：自由变量查找

x = 10

def outer():
    x = 20
    def inner():
        print(x)
    return inner

closure = outer()
closure()  # 输出 20

在这个例子中，inner 函数打印的是外部函数 outer 中的 x，而不是全局作用域中的 x。这是因为 inner 函数在查找 x 时首先会查找 outer 的作用域。

总结

闭包是 Python 中一个非常强大的特性，它可以让我们在嵌套函数中访问外部函数的局部变量，从而创造出更加灵活和高效的代码。通过闭包，我们能够构建函数工厂、保持状态和实现延迟计算等功能，从而增强代码的表达能力和可维护性。

希望本文能够帮助你更好地理解 Python 中的闭包。如果你对闭包有任何疑问，欢迎在评论区留言讨论！