【 Python 全栈开发 - WEB开发篇 - 36 】闭包与装饰器

---

一、闭包

1.1 概念

闭包是指一个函数对象，它可以访问到其词法作用域之外的变量。换句话说，闭包是一个函数和其相关的引用环境组合而成的实体。

1.2 实现方式

在 Python 中，闭包可以通过在一个函数内部定义另一个函数，并且内部函数引用了外部函数的变量来实现。当外部函数返回内部函数时，内部函数仍然可以访问外部函数的变量，这就形成了闭包。

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

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

在这个例子中，outer_function是外部函数，它接受一个参数 x。内部函数inner_function引用了outer_function的参数x，并返回 x + y 的结果。当我们调用outer_function(10)时，返回的是inner_function，这个返回的函数就是一个闭包。我们可以将闭包赋值给一个变量 closure，然后调用closure(5)，输出结果为 15。这是因为 closure 保持了对 outer_function 的参数 x 的引用。

1.3 应用场景

闭包在很多场景中都有所应用，比如：

• 保护数据：闭包可以将数据封装在内部函数中，只能通过特定的函数访问，从而起到保护数据的作用。
• 延迟计算：闭包可以将一些计算逻辑延迟到函数调用时才执行，从而提高程序的性能。
• 记忆化缓存：闭包可以将一些计算结果缓存起来，避免重复计算，提高程序的效率。
• 回调函数：闭包可以作为回调函数，用于处理异步操作。

1.4 优势与劣势

闭包的优势在于它可以保护数据、延迟计算、记忆化缓存等，这些特性在某些场景下非常有用。然而，闭包也有一些劣势，比如闭包会占用内存空间，因为它会保持对外部变量的引用，导致这些变量无法被垃圾回收。此外，闭包的使用也需要注意一些问题，比如变量的作用域、内存泄漏等。

1.5 注意事项

1. 避免循环引用：当闭包中引用了外部函数的变量时，需要注意避免循环引用，否则会导致内存泄漏。
2. 注意变量的作用域：在闭包中，内部函数可以访问外部函数的变量，但是不能修改它们，如果需要修改，可以使用nonlocal关键字声明变量。
3. 尽量避免使用过多的闭包：过多的闭包会增加代码的复杂性，降低可读性和可维护性，所以在使用闭包时需要慎重考虑。

1.6 闭包项目讲解（计时器）

下面我们来讲解一个使用闭包的实际项目——计时器。计时器可以用于记录函数的执行时间，方便性能优化和调试。

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数 {func.__name__} 的执行时间为 {end_time - start_time} 秒")
        return result
    return wrapper

@timer
def my_function():
    time.sleep(2)
    print("执行函数")

my_function()

在这个例子中，我们定义了一个装饰器函数timer，它接受一个函数作为参数，并返回一个闭包wrapper。闭包wrapper记录了函数执行的开始时间和结束时间，并计算出函数的执行时间。最后，我们使用@timer装饰器将my_function函数进行装饰，调用my_function()时，会自动计算函数的执行时间并打印出来。

通过这个例子，我们可以看到闭包的强大之处。使用闭包，我们可以在不修改原函数的情况下，为函数添加额外的功能，比如计时、缓存等。这样可以提高代码的重用性和可扩展性。

总结：
闭包是一个函数和其相关的引用环境组合而成的实体，它可以访问到其词法作用域之外的变量。在 Python 中，闭包可以通过在一个函数内部定义另一个函数，并且内部函数引用了外部函数的变量来实现。闭包在保护数据、延迟计算、记忆化缓存和回调函数等场景中都有应用。闭包的优势在于它可以提供一种灵活的方式来扩展函数的功能，但也需要注意避免循环引用和变量作用域等问题。通过一个计时器的示例项目，我们展示了闭包的实际应用。闭包是 Python 中强大的特性之一，合理使用闭包可以提高代码的可读性和可维护性。

---

二、装饰器

Python 装饰器是一种用于修改、增强或包装函数或类的语法结构。它通过在被装饰对象的前后添加额外的功能，而不需要修改被装饰对象的源代码。

2.1 装饰器的概念

装饰器是 Python 中一种特殊的语法结构，它可以在不修改被装饰对象源代码的情况下，对其进行功能增强、修改或包装。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。这种特性使得装饰器可以在不改变原有函数的调用方式的前提下，动态地为函数添加额外的功能。

2.2 装饰器的实现方式

装饰器有两种常见的实现方式，分别是函数装饰器和类装饰器。

2.2.1 函数装饰器

函数装饰器是最常见的装饰器实现方式，它是一个高阶函数，接受一个函数作为参数，并返回一个新的函数。函数装饰器通常使用@语法糖来使用，将装饰器应用到被装饰函数上。

下面是一个简单的函数装饰器示例：

def decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function execution")
        result = func(*args, **kwargs)
        print("After function execution")
        return result
    return wrapper

@decorator
def my_function():
    print("Function execution")

my_function()

在上面的示例中，我们定义了一个名为decorator的函数装饰器。该装饰器接受一个函数作为参数，并返回一个新的函数wrapper。在wrapper函数中，我们可以在被装饰函数执行前后添加额外的功能。最后，我们使用@decorator语法糖将装饰器应用到my_function函数上。

运行上述代码，输出结果为：

Before function execution
Function execution
After function execution

可以看到，在被装饰函数my_function执行之前和之后，装饰器中的代码都被执行了。

2.2.2 类装饰器

类装饰器是另一种装饰器的实现方式，它是一个类，实现了__call__方法。类装饰器可以接受一个函数或类作为参数，并返回一个新的函数或类。类装饰器通常使用实例化的方式来使用，将装饰器应用到被装饰对象上。

下面是一个简单的类装饰器示例：

class Decorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before function execution")
        result = self.func(*args, **kwargs)
        print("After function execution")
        return result

@Decorator
def my_function():
    print("Function execution")

my_function()

在上面的示例中，我们定义了一个名为Decorator的类装饰器。该装饰器实现了__call__方法，并接受一个函数作为参数。在__call__方法中，我们可以在被装饰函数执行前后添加额外的功能。最后，我们使用实例化的方式将装饰器应用到my_function函数上。

运行上述代码，输出结果为：

Before function execution
Function execution
After function execution

可以看到，类装饰器的效果和函数装饰器是一样的。

2.3 装饰器的应用场景

装饰器在 Python 中有广泛的应用场景，它可以用于实现日志记录、性能分析、权限校验、缓存、重试等功能。

2.3.1 日志记录

日志记录是一个常见的应用场景，通过装饰器可以方便地为函数或类添加日志记录功能，记录函数的输入参数、输出结果和执行时间。

下面是一个简单的日志记录装饰器示例：

import logging
import time

def log_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        logging.info(f"Function {func.__name__} executed in {execution_time} seconds")
        return result
    return wrapper

@log_decorator
def my_function():
    time.sleep(1)
    print("Function execution")

my_function()

在上面的示例中，我们定义了一个名为log_decorator的装饰器，它在被装饰函数执行前后记录了函数的执行时间。最后，我们使用@log_decorator语法糖将装饰器应用到my_function函数上。

2.3.2 性能分析

性能分析是另一个常见的应用场景，通过装饰器可以方便地对函数或类的性能进行分析，找出性能瓶颈并进行优化。

下面是一个简单的性能分析装饰器示例：

import time

def profile_decorator(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__} executed in {execution_time} seconds")
        return result
    return wrapper

@profile_decorator
def my_function():
    time.sleep(1)
    print("Function execution")

my_function()

在上面的示例中，我们定义了一个名为profile_decorator的装饰器，它在被装饰函数执行前后计算了函数的执行时间。最后，我们使用@profile_decorator语法糖将装饰器应用到my_function函数上。

2.3.3 权限校验

权限校验是一个常见的应用场景，通过装饰器可以方便地为函数或类添加权限校验功能，确保只有具有相应权限的用户可以访问。

下面是一个简单的权限校验装饰器示例：

def permission_required(permission):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if check_permission(permission):
                return func(*args, **kwargs)
            else:
                raise PermissionError("Permission denied")
        return wrapper
    return decorator

@permission_required("admin")
def my_function():
    print("Function execution")

my_function()

在上面的示例中，我们定义了一个名为permission_required的装饰器工厂函数，它接受一个权限参数，并返回一个装饰器。在装饰器中，我们根据权限参数进行权限校验，如果权限校验通过，则执行被装饰函数，否则抛出PermissionError异常。最后，我们使用@permission_required("admin")语法糖将装饰器应用到my_function函数上。

2.3.4 缓存

缓存是一个常见的应用场景，通过装饰器可以方便地为函数或类添加缓存功能，提高函数的执行效率。

下面是一个简单的缓存装饰器示例：

import functools

def cache_decorator(func):
    cache = {}

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = (args, frozenset(kwargs.items()))
        if key in cache:
            return cache[key]
        else:
            result = func(*args, **kwargs)
            cache[key] = result
            return result
    return wrapper

@cache_decorator
def my_function(n):
    print("Function execution")
    return n * n

print(my_function(2))
print(my_function(2))

在上面的示例中，我们定义了一个名为cache_decorator的装饰器，它使用一个字典来作为缓存。在装饰器中，我们根据函数的输入参数作为键来进行缓存查找，如果查找到了结果，则直接返回缓存的结果，否则执行被装饰函数，并将结果存入缓存。最后，我们可以看到，第二次调用my_function(2)时，直接返回了缓存的结果。

2.4 装饰器的优势与劣势

2.4.1 优势

装饰器具有以下优势：

• 无需修改被装饰对象的源代码：装饰器可以在不改变被装饰对象的源代码的情况下，对其进行功能增强、修改或包装。
• 可复用性：装饰器可以对多个函数或类进行相同的功能增强、修改或包装，提高了代码的复用性。
• 可拆卸性：装饰器可以随时添加或移除，不会对被装饰对象产生影响。
• 动态性：装饰器可以在运行时动态地为函数或类添加额外的功能。

2.4.2 劣势

装饰器具有以下劣势：

• 装饰器会改变函数或类的调用方式：被装饰函数或类的调用方式可能会发生变化，需要注意调用方式的改变。
• 装饰器会增加代码的复杂度：装饰器会引入额外的代码，增加了代码的复杂度，需要谨慎使用。
• 装饰器可能会引入性能损耗：装饰器会在被装饰函数或类的执行前后添加额外的功能，可能会引入性能损耗，需要评估性能影响。

2.5 使用装饰器的注意事项

在使用装饰器时，需要注意以下事项：

• 被装饰对象的元信息可能会丢失：装饰器会替换被装饰对象的函数或类，可能会导致元信息的丢失，如函数名、文档字符串等。
• 装饰器的顺序可能会影响结果：如果同时应用多个装饰器，装饰器的顺序可能会影响最终的结果，需要注意装饰器的顺序。
• 装饰器的参数传递问题：如果装饰器需要接受参数，需要注意参数传递的方式，如使用闭包、使用类的实例变量等。

2.6 装饰器项目讲解

为了更好地理解装饰器的应用，我们将通过一个实际的装饰器项目进行讲解。该项目是一个简单的 HTTP 框架，使用装饰器实现了路由功能。

2.6.1 项目背景

我们希望实现一个简单的 HTTP 框架，可以方便地定义路由和处理函数，实现 URL 和处理函数的映射关系。

2.6.2 项目实现

首先，我们定义一个Router类，用于存储 URL 和处理函数的映射关系：

class Router:
    def __init__(self):
        self.routes = {}

    def route(self, path):
        def decorator(func):
            self.routes[path] = func
            return func
        return decorator

在Router类中，我们定义了一个route方法，它接受一个 URL 作为参数，并返回一个装饰器。在装饰器中，我们将 URL 和处理函数的映射关系存储到routes字典中。

接下来，我们定义一个Application类，用于处理 HTTP 请求：

class Application:
    def __init__(self):
        self.router = Router()

    def __call__(self, environ, start_response):
        path = environ.get('PATH_INFO', '/')
        func = self.router.routes.get(path)
        if func:
            response_body = func()
            status = '200 OK'
        else:
            response_body = '404 Not Found'
            status = '404 Not Found'
        response_headers = [('Content-Type', 'text/plain'), ('Content-Length', str(len(response_body)))]
        start_response(status, response_headers)
        return [response_body.encode()]

在Application类中，我们定义了一个__call__方法，它接受environ和start_response两个参数，用于处理 HTTP 请求。

在__call__方法中，我们首先获取请求的 URL，并根据 URL 查找对应的处理函数。如果找到了处理函数，则执行该函数，并将返回结果作为响应内容；如果未找到处理函数，则返回404 Not Found。

最后，我们定义一个app对象，用于处理 HTTP 请求：

app = Application()

@app.router.route('/')
def index():
    return 'Hello, World!'

@app.router.route('/about')
def about():
    return 'About Page'

在上述代码中，我们首先创建了一个Application对象app，然后使用app.router.route装饰器定义了两个处理函数index和about，并指定了对应的 URL。

2.6.3 项目使用

为了使用装饰器项目，我们需要使用一个 WSGI 服务器来运行app对象。下面是一个使用wsgiref模块的示例：

from wsgiref.simple_server import make_server

httpd = make_server('', 8000, app)
print("Serving on port 8000...")
httpd.serve_forever()

在上述代码中，我们使用make_server函数创建一个 WSGI 服务器，并将app对象作为参数传递给服务器。最后，我们通过调用serve_forever方法来启动服务器。

运行上述代码后，可以在浏览器中访问 http://localhost:8000 和 http://localhost:8000/about，分别看到 Hello, World! 和 About Page 的响应。

总结:
装饰器是Python中非常有用的语法结构，可以方便地对函数或类进行功能增强、修改或包装，提高了代码的复用性和灵活性。在使用装饰器时，需要注意被装饰对象的元信息可能会丢失、装饰器的顺序可能会影响结果、装饰器的参数传递问题等。