python入门第十四节--装饰器

千澜空

于 2024-08-18 22:18:45 发布

阅读量585

点赞数 17

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_68472237/article/details/141306223

版权

1. 引言

什么是装饰器？

Python装饰器是一种用于修改函数或方法行为的高级特性。它们允许开发者在不改变函数内部代码的情况下，动态地添加或修改函数的功能。装饰器的本质是一种能够接收函数作为输入并返回一个新函数的高阶函数。

装饰器的用途和重要性

装饰器在Python开发中扮演着非常重要的角色，主要体现在以下几个方面：
代码重用：装饰器可以将通用的功能抽离出来，例如日志记录、权限验证或缓存，从而减少重复代码。
代码简化：通过装饰器，复杂的功能可以以简洁的方式应用到多个函数上，使得代码更加简洁和可读。
解耦逻辑：装饰器将跨切关注点（如事务处理、性能监控）与业务逻辑分离，增强了代码的模块化和维护性。

Python中装饰器的广泛应用场景

装饰器在Python的实际开发中有着广泛的应用。以下是一些常见的使用场景：
日志记录：通过装饰器自动记录函数的调用情况、参数和返回值，方便调试和审计。
权限验证：在Web应用中，装饰器常用于检查用户权限，确保只有授权用户才能访问某些功能。
缓存：装饰器可以缓存函数的计算结果，以提高性能，尤其是在需要频繁调用某些耗时操作时。
事务管理：在数据库操作中，装饰器可以用来自动管理事务的开启和提交，确保数据一致性。
性能监控：装饰器能够用于测量函数的执行时间，从而帮助优化代码性能。

2. 装饰器的基本概念

函数即对象：Python中函数的本质

在Python中，函数是一等公民（first-class citizen），这意味着函数和其他对象（如数字、字符串、列表等）一样，可以赋值给变量、作为参数传递、作为返回值，甚至存储在数据结构中。这个特性使得Python的函数非常灵活，可以像操作其他对象一样操作函数。

例如：

def greet(name):
    return f"Hello, {name}!"

say_hello = greet
print(say_hello("World"))  # 输出: Hello, World!

在这个例子中，我们将greet函数赋值给了say_hello变量，这说明函数在Python中是可以被引用和操作的对象。这种特性是理解装饰器的基础，因为装饰器本质上就是一种可以操作函数的特殊函数。

高阶函数：将函数作为参数或返回值

高阶函数（higher-order function）是指能够接收函数作为参数或者将函数作为返回值的函数。在Python中，高阶函数非常常见，许多内置函数（如map、filter、sorted等）都是高阶函数。

例如：

def add(a, b):
    return a + b

def operate(func, x, y):
    return func(x, y)

result = operate(add, 5, 3)
print(result)  # 输出: 8

在这个例子中，operate函数就是一个高阶函数，因为它接收了另一个函数add作为参数。装饰器利用了这一特性，通过将目标函数作为参数传递给装饰器函数，从而在不修改目标函数代码的情况下，增强或改变其行为。

闭包：装饰器的基础

闭包（closure）是指在函数内部定义的函数，可以引用外部函数的变量，并且这些变量即使外部函数结束执行后仍然存在。闭包的概念是理解装饰器的核心，因为装饰器通常通过闭包来保存状态或创建封装的函数行为。

例如：

def outer(message):
    def inner():
        print(message)
    return inner

my_func = outer("Hello, Python!")
my_func()  # 输出: Hello, Python!

在这个例子中，inner函数引用了外部函数outer的message变量，即使outer函数已经执行完毕并返回，message变量依然可以在inner函数中使用。这个特性使得闭包可以用于在装饰器中创建持久的状态或行为。

通过理解函数即对象、高阶函数和闭包这三个基本概念，你就掌握了装饰器的核心原理。装饰器正是利用这些概念，在不改变函数定义的情况下，为函数增加额外的功能或修改其行为。

3. 定义一个简单的装饰器

装饰器的基本语法

装饰器的基本语法非常简单，它通过定义一个接收函数并返回新函数的高阶函数来实现。这个新函数通常在执行原函数前后添加一些额外的操作。装饰器函数的基本结构如下：

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

在这个例子中，my_decorator 是一个装饰器函数，它接收一个函数 func 作为参数，并返回一个名为 wrapper 的新函数。在 wrapper 中，原函数 func 被调用前后，分别执行了一些额外的操作。

实现一个简单的无参数装饰器

让我们通过一个具体的例子来实现并使用这个装饰器：

def my_decorator(func):
    def wrapper():
        print("在函数执行之前做一些准备工作")
        func()
        print("在函数执行之后做一些收尾工作")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

运行结果如下：

在函数执行之前做一些准备工作
Hello!
在函数执行之后做一些收尾工作

在这个例子中，我们定义了一个名为 say_hello 的函数，并使用 @my_decorator 语法糖将 my_decorator 应用到该函数上。装饰器 my_decorator 在 say_hello 函数执行前后插入了额外的逻辑。

使用 `@` 语法糖

Python 提供了 @ 语法糖，使得装饰器的使用更加直观和简洁。你只需要在函数定义之前添加 @装饰器名称 即可将装饰器应用到该函数上，如同前面的例子所示。

语法糖让代码更加清晰，特别是当你希望对多个函数应用同一个装饰器时。例如：

@my_decorator
def greet():
    print("Greetings!")

greet()

与手动调用装饰器函数相比，@ 语法糖不仅简化了代码，还使得装饰器的意图更为明显。

4. 带参数的装饰器

定义和使用带参数的装饰器

有时，我们需要在装饰器中传递参数，以实现更灵活的功能。带参数的装饰器实际上是一个三层嵌套的函数结构：外层函数用于接收装饰器参数，中间层函数用于接收目标函数，内层函数则是封装实际逻辑的 wrapper。

例如，创建一个记录函数执行时间的装饰器，可以接收一个参数来指定日志的详细级别：

import time

def log_execution(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            print(f"[{level}] {func.__name__} 执行时间: {end_time - start_time:.4f} 秒")
            return result
        return wrapper
    return decorator

在这个例子中，log_execution 是外层函数，它接收一个 level 参数，用于指定日志的级别。decorator 是中间层函数，接收目标函数 func 作为参数。wrapper 是内层函数，实际执行原函数并记录其执行时间。

示例：记录函数执行时间的装饰器

现在，我们可以使用这个装饰器来装饰一个函数，并指定日志级别：

@log_execution(level="INFO")
def slow_function():
    time.sleep(2)
    print("函数执行完毕")

slow_function()

运行结果如下：

函数执行完毕
[INFO] slow_function 执行时间: 2.0001 秒

这个例子展示了带参数装饰器的强大功能。通过将 level 传递给装饰器，我们可以灵活控制日志的输出级别，同时还保持了代码的简洁和易读性。

5. 装饰多个函数

如何在多个函数上应用相同的装饰器

装饰器的一个强大之处在于它可以在多个函数上重复使用，从而避免重复代码。要将相同的装饰器应用到多个函数，你只需在每个函数定义前添加相同的 @装饰器名称 即可。

例如，假设你有一个用于记录日志的装饰器：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned: {result}")
        return result
    return wrapper

你可以将这个装饰器应用到多个函数上，如下所示：

@log_decorator
def add(a, b):
    return a + b

@log_decorator
def multiply(a, b):
    return a * b

add(2, 3)
multiply(4, 5)

运行结果：

Calling add with args: (2, 3), kwargs: {}
add returned: 5
Calling multiply with args: (4, 5), kwargs: {}
multiply returned: 20

在这个例子中，log_decorator 被应用到 add 和 multiply 函数上，这使得这两个函数在调用时都会记录日志信息。

示例：日志记录装饰器

日志记录是装饰器最常见的应用之一，它可以帮助开发者跟踪函数的执行情况。这里展示一个简单的日志记录装饰器：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Function {func.__name__} started.")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} ended.")
        return result
    return wrapper

你可以将这个装饰器应用到多个函数上，例如：

@log_decorator
def greet(name):
    print(f"Hello, {name}!")

@log_decorator
def farewell(name):
    print(f"Goodbye, {name}!")

greet("Alice")
farewell("Bob")

结果将是：

Function greet started.
Hello, Alice!
Function greet ended.
Function farewell started.
Goodbye, Bob!
Function farewell ended.

通过使用装饰器，你能够轻松地为多个函数添加相同的功能，而无需修改函数内部代码。

6. 装饰器的嵌套

多个装饰器的组合使用

在Python中，函数可以同时被多个装饰器修饰，这称为装饰器的嵌套使用。多个装饰器会按照从内到外的顺序依次应用。使用嵌套装饰器时，最靠近函数的装饰器会最先被应用。

例如，考虑以下两个装饰器：

def uppercase_decorator(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def greeting_decorator(func):
    def wrapper(*args, **kwargs):
        return f"Hello, {func(*args, **kwargs)}"
    return wrapper

如果你将这两个装饰器嵌套在一起使用：

@greeting_decorator
@uppercase_decorator
def greet(name):
    return name

print(greet("alice"))

输出将是：

Hello, ALICE

在这个例子中，uppercase_decorator 首先将返回值转换为大写，然后 greeting_decorator 再在其前面添加 "Hello, "。

解释装饰器的应用顺序（从内到外）

装饰器的应用顺序是从内到外的，也就是说，最内层的装饰器最先被应用，而最外层的装饰器最后被应用。在上面的例子中，虽然 greeting_decorator 位于 uppercase_decorator 之上，但它是最后被应用的。

装饰器的嵌套顺序会影响最终的结果，因此在设计装饰器时，需要考虑到这一点，以确保装饰器按照预期的顺序执行。

7. 类装饰器

使用类实现装饰器

除了使用函数定义装饰器外，Python还允许你使用类来实现装饰器。类装饰器的实现通常更适合需要保持状态或管理资源的场景。

一个类装饰器需要实现 __call__ 方法，使其实例能够像函数一样被调用。以下是一个简单的类装饰器示例：

class CounterDecorator:
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} has been called {self.count} times")
        return self.func(*args, **kwargs)

你可以像使用函数装饰器一样使用这个类装饰器：

@CounterDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
say_hello("Bob")

输出如下：

say_hello has been called 1 times
Hello, Alice!
say_hello has been called 2 times
Hello, Bob!

在这个例子中，CounterDecorator 记录了函数被调用的次数。通过使用类装饰器，你可以轻松实现类似的功能，同时保持代码的清晰和可维护性。

示例：计数器装饰器

类装饰器最常见的一个应用就是计数器装饰器，它可以用来统计某个函数被调用的次数。这在需要监控函数使用情况或性能分析时特别有用。

上面展示的 CounterDecorator 就是一个简单的计数器装饰器示例。通过这种方式，你可以在类中保存状态，从而实现更加复杂的装饰器逻辑。

8. 内置装饰器

常见的Python内置装饰器

Python提供了几个常用的内置装饰器，主要用于类的方法修饰。以下是一些常见的内置装饰器及其用途：

@staticmethod: 将方法定义为静态方法，不需要实例化类即可调用，不依赖实例或类本身。

class MyClass:
    @staticmethod
    def static_method():
        print("This is a static method")

MyClass.static_method()

@classmethod: 将方法定义为类方法，接收类对象作为第一个参数（通常命名为cls），可以操作类属性和方法。

class MyClass:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1

MyClass.increment()
print(MyClass.count)  # 输出: 1

@property: 将类的方法转换为属性访问。使用@property可以定义一个方法，使其可以像访问属性一样调用。

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

obj = MyClass(10)
print(obj.value)  # 输出: 10

这些装饰器的用途和示例

@staticmethod: 用于不需要访问实例或类状态的方法，适合那些与类逻辑相关，但不依赖实例数据的工具方法。
@classmethod: 适合需要访问或修改类状态（而不是实例状态）的场景，如实现工厂方法、修改类属性等。
@property: 用于将方法封装成属性访问，以便在获取或设置属性时添加逻辑。通常用于控制对属性的访问或计算属性值。

这些内置装饰器极大地简化了类的设计，使得Python的面向对象编程更加灵活和直观。

9. 实战案例

将装饰器应用于实际项目中的具体场景

装饰器在实际项目中有着广泛的应用，特别是在Web开发、数据处理和性能优化等领域。以下是一些常见的实际应用场景：

认证装饰器:
在Web应用中，装饰器经常用于权限验证，确保只有经过身份验证的用户才能访问某些资源。

def login_required(func):
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            raise PermissionError("User not authenticated")
        return func(*args, **kwargs)
    return wrapper

缓存装饰器:
对于一些需要频繁调用且计算开销大的函数，可以使用缓存装饰器来保存结果，从而避免重复计算。
```
from functools import lru_cache

@lru_cache(maxsize=32)
def expensive_com
	putation(n):
    # 复杂的计算
    return n * n
```
使用 @lru_cache 可以自动缓存最近的计算结果，提高性能。

示例：认证装饰器、缓存装饰器

在实际开发中，装饰器的应用非常广泛。例如，Django的 @login_required 就是一个经典的认证装饰器，用于保护视图函数，确保用户已经登录。

缓存装饰器则在需要优化性能的场景中非常有用，比如计算密集型任务或需要频繁访问的数据。在Python中，functools.lru_cache 是一个功能强大的内置装饰器，它可以大幅度提高函数的执行效率。

通过实际案例的展示，你可以看到装饰器在项目中的实际应用价值和灵活性。装饰器不仅帮助开发者编写更加简洁和可维护的代码，还可以通过其强大的扩展性，轻松地为函数和方法添加各种通用功能。

千澜空

关注

17
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
python入门第十四节--装饰器

Python装饰器是一种用于修改函数或方法行为的高级特性。它们允许开发者在不改变函数内部代码的情况下，动态地添加或修改函数的功能。装饰器的本质是一种能够接收函数作为输入并返回一个新函数的高阶函数。装饰器的基本语法非常简单，它通过定义一个接收函数并返回新函数的高阶函数来实现。这个新函数通常在执行原函数前后添加一些额外的操作。func()在这个例子中，是一个装饰器函数，它接收一个函数func作为参数，并返回一个名为wrapper的新函数。在wrapper中，原函数func被调用前后，分别执行了一些额外的操作。
复制链接

扫一扫