python闭包（Closures）（闭包是一个函数对象，它记住了封闭作用域中的值）（Lexical Scope、static scope：词法作用域、静态作用域）

最新推荐文章于 2025-02-19 21:41:26 发布

Dontla

最新推荐文章于 2025-02-19 21:41:26 发布

阅读量1.3k

点赞数 37

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/Dontla/article/details/136162797

版权

Python 专栏收录该内容

509 篇文章

订阅专栏

文章目录

Understanding Python Closures: A Deep Dive（深入理解Python闭包）

Understanding Python Closures: A Deep Dive（深入理解Python闭包）

In the world of Python, closures represent a powerful yet often misunderstood concept.

在Python的世界里，闭包代表了一个强大但经常被误解的概念。

Rooted in the principles of functional programming, closures provide a unique way to retain（保持） state and data across function calls without resorting（采取某手段或方法） to global variables or object-oriented techniques.

基于函数式编程的原则，闭包提供了一种独特的方式，在函数调用之间保持状态和数据，而不需要使用全局变量或面向对象的技术。

This article aims to demystify（使明白易懂） closures, exploring their intricacies（错综复杂的事物(或细节)）, use cases, and advantages.

本文旨在揭开闭包的神秘面纱，探索它们的复杂性、用例和优势。

What is a Closure?（什么是闭包？）

At its core, a closure is a function object that remembers values in enclosing（封闭的） scopes（作用域） regardless of whether those scopes are still present in memory.

在其核心，闭包是一个函数对象，它记住了封闭作用域中的值，无论这些作用域是否仍然存在于内存中。

To put it another way, a closure gives you access to an outer function’s scope from an inner function.

换句话说，闭包允许你从一个内部函数访问外部函数的作用域。

This behavior is not just about retaining state; it also encapsulates（封装） that state, providing a mechanism（机制） for data hiding and encapsulation.

这种行为不仅仅是关于保持状态；它还封装了那个状态，提供了一种数据隐藏和封装的机制。

Understanding Lexical Scope（理解词法作用域）

Before diving into closures, it’s essential to understand the concept of lexical scope (also known as static scope).

在深入研究闭包之前，理解词法作用域（也称为静态作用域）的概念是必要的。

In Python, the scope of variables is determined at the time the code is written, not when it’s executed.

在Python中，变量的作用域是在代码编写时确定的，而不是在执行时确定的。

This means that functions can refer to variables from the scope in which they were defined, not necessarily the scope from which they are called.

这意味着函数可以引用它们被定义时的作用域中的变量，而不一定是它们被调用时的作用域。

def outer_func():
    x = "Hello"
    def inner_func():
        print(x)  # x is referenced from the outer_func's scope
    inner_func()

outer_func()  # Outputs: Hello

Creating a Closure in Python（在Python中创建闭包）

A closure occurs naturally when a nested（嵌套的） function references variables from the enclosing scope.

当一个嵌套函数引用了封闭作用域中的变量时，自然就形成了闭包。

Steps to creating a closure（创建闭包的步骤）

Here’s a step-by-step guide to creating a closure:

以下是创建闭包的分步指南：

1. Define an Outer Function（定义一个外部函数）

This function contains a variable and an inner function.

这个函数包含一个变量和一个内部函数。

2. Define an Inner Function（定义一个内部函数）

This nested function refers to the outer function’s variable.

这个嵌套函数引用外部函数的变量。

3. Return the Inner Function（返回内部函数）

Instead of calling it, return it from the outer function.

不是调用它，而是从外部函数返回它。

Code example（代码示例）

def outer_func(text):
    def inner_func():
        print(text)
    return inner_func  # Note the absence of parentheses（注意没有括号）

my_closure = outer_func("Hello, World!")
my_closure()  # Outputs: Hello, World!

Here, my_closure is a closure that retains the text argument passed to outer_func, even after outer_func has finished execution.

这里，my_closure是一个闭包，它保留了传递给outer_func的text参数，即使在outer_func执行完成后也是如此。

Use Cases for Closures（闭包的用例）

Closures are versatile（多用途的） and can be used in various scenarios（场景）, including:

闭包是多才多艺的，可以在各种场景中使用，包括：

Data Encapsulation and Hiding（数据封装和隐藏）

By using closures, data can be hidden from the global scope, reducing potential conflicts.

通过使用闭包，数据可以从全局作用域中隐藏，减少潜在的冲突。

示例

def outer_function(x):
    hidden_data = x

    def inner_function():
        print(hidden_data)

    return inner_function

# 创建一个闭包
closure = outer_function(10)
# 执行闭包
closure()  # 输出：10

在这个例子中，变量hidden_data被封装在outer_function内部，它对外部世界是隐藏的，只有内部的inner_function可以访问它。

Callback Functions（回调函数）

They are extensively（广泛地） used in asynchronous（异步的） programming, GUI applications, or in situations where custom handling is required.

它们广泛用于异步编程、GUI应用程序或需要自定义处理的情况。

示例

def apply_async(func, args, *, callback):
    result = func(*args)

    callback(result)

def print_result(result):
    print('Got:', result)

def add(x, y):
    return x + y

apply_async(add, (2, 3), callback=print_result)  # 输出：Got: 5

在这个例子中，我们创建了一个回调函数print_result，它将在异步操作完成时被调用。在这种情况下，apply_async函数执行一些操作（在本例中为添加操作），然后调用回调函数来处理结果。

Function Factories（函数工厂）

Closures can generate functions with specific behaviors dynamically, based on arguments or environmental conditions.

闭包可以根据参数或环境条件动态生成具有特定行为的函数。

示例

def make_multiplier_of(n):
    def multiplier(x):
        return x * n
    return multiplier

times3 = make_multiplier_of(3)
print(times3(9))  # 输出：27

times5 = make_multiplier_of(5)
print(times5(3))  # 输出：15

在这个例子中，make_multiplier_of函数接受一个参数n，并返回一个新的函数，这个新的函数会将它的输入乘以n。这是一个函数工厂的例子：我们动态地创建并返回了函数。

Advantages of Using Closures（使用闭包的优势）

Memory Efficiency（内存效率）

Closures can lead to more memory-efficient code by avoiding global variables or unnecessary class definitions.

通过避免全局变量或不必要的类定义，闭包可以导致更加内存高效的代码。

Encapsulation（封装）

They provide a method of data hiding, helping to avoid namespace pollution.

它们提供了一种数据隐藏的方法，有助于避免命名空间污染。

Simplicity（简洁）

For certain design patterns, such as decorators or factories, closures can offer a simpler（更简单的） solution than classes.

对于某些设计模式，例如装饰器或工厂，闭包可以提供比类更简单的解决方案。

Common pitfalls and solutions（常见陷阱和解决办法）

Common Pitfalls（常见陷阱）

While closures are powerful, they come with their own set of challenges:

虽然闭包很强大，但它们也有自己的一套挑战：

Unintended Retaining（非预期的保留）

Closures can inadvertently（无意的） hold onto resources longer than needed, potentially leading to memory leaks.

闭包可能会无意中保留资源超过所需时间，可能导致内存泄漏。

Complexity（复杂性）

Misuse（滥用） of closures can lead to code that is hard to read and maintain.

误用闭包可能导致代码难以阅读和维护。

How to Avoid Them（如何避免它们？）

To mitigate（减轻） these issues, it’s important to:

为了减轻这些问题，重要的是：

Clearly document closures, explaining why they’re being used.
明确记录闭包，解释它们为什么被使用。
Monitor resource usage in long-running applications to avoid memory leaks.
监控长时间运行的应用程序中的资源使用情况，以避免内存泄漏。
Consider alternatives, like classes, if a closure makes the code unnecessarily complex.
如果闭包使代码不必要地复杂化，考虑其他选择，如类。

Conclusion（结论）

Closures in Python are a fundamental（基本的） concept that, when understood and applied correctly, can significantly enhance the functionality（功能）, readability（可读性）, and efficiency of your code.

Python中的闭包是一个基本概念，当正确理解和应用时，可以显著增强代码的功能、可读性和效率。

They allow for elegant solutions to problems involving state retention（保留） and data encapsulation.

它们允许优雅地解决涉及状态保留和数据封装的问题。

However, like any powerful tool, they must be used judiciously（审慎地） to avoid introducing complexity（复杂性） or inefficiencies（低效） into your programs.

然而，像任何强大的工具一样，必须谨慎使用它们，以避免将复杂性或低效引入到程序中。

By grasping the principles outlined（概述的） in this article and practicing their implementation, developers can leverage（利用） closures to create cleaner, more efficient, and more Pythonic code.

通过掌握本文概述的原则并实践它们的实现，开发者可以利用闭包创建更干净、更高效、更符合Python风格的代码。