深入浅出：理解Python中的装饰器

许愿offer多多

已于 2023-12-02 17:46:44 修改

阅读量1k

点赞数 34

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

于 2023-11-29 21:27:29 首次发布

本文链接：https://blog.csdn.net/weixin_46935972/article/details/134697525

版权

python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在Python中，装饰器是一种独特而强大的工具。顾名思义，装饰器就像是给函数“装饰”上了一层额外的包装，它能够在保持原有函数逻辑不变的同时，增加新的功能或处理逻辑。

理解和掌握装饰器对于Python开发者来说都是非常有价值的。工作中熟练使用装饰器可以使代码更加简洁、优雅，还能提高代码的复用性和可读性。本文将对装饰器进行全面解析，帮助初学者理解并掌握这一高级特性。

装饰器基础

什么是装饰器？

首先，我们要理解的是，装饰器本质上是一个函数，它的特殊之处在于，它可以接收一个函数作为参数，并返回一个新的函数。这听起来可能有点抽象，但其实装饰器的核心思想是：在不改变原函数的定义和调用方式的情况下，为函数添加新的功能。

在Python中，由于函数是一等公民，我们可以把它们赋给变量、作为参数传递，甚至可以在其他函数内部定义和返回。这些特性使得装饰器在Python中实现起来既自然又高效。

举个例子

想象一下，有一个餐厅里的厨师，他负责制作各种菜肴。这个厨师就好比是一个函数，专门完成一个特定的任务（即烹饪菜肴）。现在，假设餐厅决定对每道菜在出厨前都进行品质检查和美化摆盘。为了不打扰厨师的主要工作，餐厅聘请了一个质量监督员来完成这个额外的任务。

这个质量监督员就像是一个装饰器。每当厨师做好一道菜，质量监督员就会接手，先检查菜品的质量，然后进行美化摆盘，最后将菜品送出。在这个过程中，厨师（原函数）的工作没有发生变化，他依然按照原来的方式做菜。但是，由于有了质量监督员（装饰器）的加入，最终送到顾客手中的菜品不仅保持了原有的品质，还增加了额外的价值（品质检查和摆盘美化）。

在Python中，装饰器的作用类似。它不改变原有函数的定义和内部逻辑，而是在函数调用的前后添加额外的功能，如日志记录、性能测试、数据校验等，从而增强函数的功能性。

装饰器的工作原理

当我们说“装饰器为函数添加新的功能”，什么意思？简单来说，当我们把一个函数传递给装饰器之后，装饰器会返回一个新的函数。这个新函数通常会执行一些额外的操作，然后调用原始函数，或者甚至根本不调用原始函数。这样，我们就能在不修改原函数代码的情况下，增加额外的处理逻辑。

创建基本的装饰器

让我们来看一个简单的示例。假设我们有一个打印问候语的函数，我们想要记录每次函数被调用的时间。一种方法是直接修改这个函数，但这会违反开闭原理（对扩展开放，对修改封闭）。装饰器为我们提供了另一种选择。

def log_decorator(func):
    def wrapper():
        print(f"Function {func.__name__} is called at {time.ctime()}")
        return func()
    return wrapper

@log_decorator
def greet():
    print("Hello, world!")

greet()

# 输出
# Function greet is called at [当前时间]
# Hello, world!

在这个例子中，log_decorator 是一个装饰器，它接收一个函数 func 并返回一个新函数 wrapper。wrapper 函数在调用原始 greet 函数之前，打印了一条日志消息。通过在 greet 函数上方添加 @log_decorator，我们实际上是将 greet 函数传递给了 log_decorator，并用它返回的新函数 wrapper 替换了原始的 greet 函数。

理解@符号

在Python中，@符号用作装饰器的语法糖。使用 @log_decorator 直接放在函数定义之前，可以避免额外的函数调用，使代码更加简洁。例如，@log_decorator 实际上是 greet = log_decorator(greet)的简写形式。

装饰器的进阶使用

在我们掌握了装饰器的基础知识之后，可以了解一些高级和实用的装饰器使用方式。这些进阶技巧将使我们能够在更复杂的场景中有效地运用装饰器。

带参数的装饰器

在基础的装饰器示例中，我们的装饰器没有接受任何参数。但在实际应用中，我们经常需要更灵活的装饰器，它们能够根据不同的参数改变行为。为了实现这一点，我们可以创建一个接受参数的装饰器。

让我们来看一个例子，我们想要一个能够根据参数定制日志级别的装饰器：

def log_level_decorator(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "info":
                print(f"[INFO] {func.__name__} is called.")
            elif level == "warning":
                print(f"[WARNING] {func.__name__} is being used.")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log_level_decorator(level="info")
def some_function():
    print("Function body.")

some_function()


# 输出
# [INFO] some_function is called.
# Function body.

在这个例子中，log_level_decorator 是一个返回装饰器的函数。我们首先调用 log_level_decorator，传入我们想要的日志级别，然后它返回一个真正的装饰器。这种方式让我们的装饰器更加灵活，能够适应更多变化的需求。

类装饰器

除了使用函数作为装饰器之外，我们还可以使用类来实现装饰器。这种方式特别适合那些需要维护状态或者需要在装饰器中实现复杂逻辑的情况。

以下是一个使用类装饰器的示例：

class CountCallsDecorator:
    def __init__(self, func):
        self.func = func
        self.call_count = 0

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

@CountCallsDecorator
def example_function():
    print("Function body.")

example_function()
example_function()


# 输出
# Function example_function has been called 1 times
# Function body.
# Function example_function has been called 2 times
# Function body.

在这里，CountCallsDecorator 类通过定义 __call__ 方法，使得它的实例可以像普通函数一样被调用。每当装饰的函数被调用时，它都会增加 call_count 并打印计数。

装饰器的实际应用

在我们掌握了装饰器的基础和高级用法之后，下面举一些常见装饰器在实际开发过程中的应用场景。

性能测试：计算函数执行时间

示例代码

import time

def time_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} executed in {end_time - start_time} seconds.")
        return result
    return wrapper

@time_decorator
def some_heavy_function():
    time.sleep(2)  # 模拟耗时操作
    return "Function completed"

print(some_heavy_function())

# 输出
# some_heavy_function executed in 2.002 seconds.
# Function completed

这个装饰器 time_decorator 在被装饰的函数执行前后记录时间，计算出执行所需的总时间。

权限校验：用户权限检查

在Web应用或任何需要用户权限管理的系统中，权限校验是一个关键的安全措施。装饰器可以用来优雅地实现权限检查逻辑。

示例代码

def admin_required(func):
    def wrapper(*args, **kwargs):
        user = get_current_user()
        if user is not None and user.is_admin:
            return func(*args, **kwargs)
        else:
            return "Access denied: Admin privileges required."

    return wrapper

@admin_required
def delete_user(user_id):
    # 删除用户的逻辑
    return f"User {user_id} has been deleted."

def get_current_user():
    # 假设的用户获取逻辑
    return {"username": "john_doe", "is_admin": True}

print(delete_user(123))


# 输出
# User 123 has been deleted.

在这个例子中，装饰器 admin_required 首先检查当前用户是否具有管理员权限。如果不具备相应权限，则阻止执行原函数，并返回访问拒绝的消息。这种方法使得权限控制逻辑与业务逻辑分离，提高了代码的可维护性和安全性。

Pytest的Fixture装饰器

作为一名测试人员，笔者第一次接触到装饰器就是在自动化测试中pytest框架接触到的，所以我们就来看一下pytest中的fixture装饰器的用法吧。

在pytest中，fixture装饰器提供了一种优雅的方式来设置测试前的预置条件和测试后的清理工作。这是一种避免重复代码和提高测试效率的方法。

示例：模拟数据的Fixture

假设我们正在测试一个需要大量模拟数据的功能。我们可以使用fixture来生成这些数据，并在测试完成后进行清理。

import pytest
import random

@pytest.fixture
def mock_data():
    data = [random.randint(1, 100) for _ in range(100)]
    yield data
    # 清理代码（如果需要）

def test_data_processing(mock_data):
    processed = process_data(mock_data)
    assert processed is not None
    # 更多的断言和数据检查

在这个例子中，mock_data fixture负责生成一个包含100个随机数的列表，并在测试函数test_data_processing中使用这些数据。使用yield关键字后，我们可以添加任何必要的清理代码，虽然在这个特定的例子中可能不需要。通过这种方式，我们确保每次测试都有新的、隔离的数据环境，这对于保证测试的准确性和可靠性至关重要。

装饰器的注意事项

在深入了解装饰器的强大功能之后，一些使用装饰器时的注意事项也要注意。学习这些细节有助于我们避免一些常见的陷阱。

保留原函数的元信息

我们在使用装饰器时可能会无意中修改或遮蔽原函数的一些重要信息，如函数的名字(__name__)和文档字符串(__doc__)等。为了避免这种情况，我们应该使用functools.wraps装饰器，它帮助保留原函数的元信息。

示例代码

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 装饰器的逻辑
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """这是函数的文档字符串"""
    pass

print(my_function.__name__)
print(my_function.__doc__)

# 输出
# my_function
# 这是函数的文档字符串

在这个示例中，使用functools.wraps确保了my_function的名字和文档字符串没有因为装饰器的应用而改变。

大家也可以参考这篇文章：https://blog.csdn.net/weixin_40576010/article/details/88639686

装饰器的嵌套使用

在实际开发中，我们可能会遇到需要嵌套使用多个装饰器的情况。在这种情况下，了解装饰器的执行顺序是非常重要的。装饰器的应用顺序是从最靠近函数的开始，向外逐层应用。

def decorator_one(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator one")
        return func(*args, **kwargs)
    return wrapper

def decorator_two(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Decorator two")
        return func(*args, **kwargs)
    return wrapper

@decorator_one
@decorator_two
def my_function():
    print("Function body")

my_function()

# 输出
# Decorator one
# Decorator two
# Function body

在这个例子中，decorator_one先于decorator_two应用，因此其输出在decorator_two之前。了解这一点有助于我们更好地组织和理解多装饰器的执行流程。

结语

通过这篇文章，我们梳理清楚了python中的装饰器从基本概念到高级应用，再到实际开发场景中的使用和相关注意事项。希望对大家的学习有帮助。

最后，我想说，这是我第一次写文章，还有许多需要学习和改进的地方。请大家多多担待！

许愿offer多多

关注

34
点赞
踩
23

收藏

觉得还不错? 一键收藏
2
评论
深入浅出：理解Python中的装饰器

首先，我们要理解的是，装饰器本质上是一个函数，它的特殊之处在于，它可以接收一个函数作为参数，并返回一个新的函数。这听起来可能有点抽象，但其实装饰器的核心思想是：在不改变原函数的定义和调用方式的情况下，为函数添加新的功能。在Python中，由于函数是一等公民，我们可以把它们赋给变量、作为参数传递，甚至可以在其他函数内部定义和返回。这些特性使得装饰器在Python中实现起来既自然又高效。通过这篇文章，我们梳理清楚了python中的解释器从基本概念到高级应用，再到实际开发场景中的装饰器使用和相关注意事项。
复制链接

扫一扫