Python 中的 @ 符号是如何工作的，装饰器在实际项目中的巧妙应用

已于 2024-07-22 13:21:51 修改
阅读量915 收藏 25
点赞数 13
分类专栏： python基础 python-AI 文章标签： python 开发语言
于 2024-07-14 18:54:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Richardlygo/article/details/140420637
版权

Python 中的 @ 符号是如何工作的

Python 中的 @ 符号是一个非常强大而又灵活的功能，它代表一个叫做"装饰器"的"语法糖"。在本文中，我们将一步步地了解它的工作原理，并通过示例代码加深理解，不改变原有函数代码的情况下，就能为它添加新功能。

为什么使用装饰器

装饰器非常有用，因为它们可以在不修改原始函数代码的情况下，向函数添加额外的行为。这在记录日志、访问控制、性能测试和缓存等场景中非常有用。

装饰器的工作原理

为了更好地理解装饰器的工作原理，我们来分步骤看一下装饰器是如何应用到函数上的。

1. 定义装饰器函数：装饰器函数通常接受一个函数作为参数，并返回一个新的函数。

2. 使用 @ 符号应用装饰器：当我们在函数定义之前使用 @ 符号时，Python 实际上是将该函数传递给装饰器，并用装饰器的返回值替换原始函数。

3. 调用被装饰的函数：调用被装饰的函数时，实际上是在调用装饰器返回的新函数。

基本的装饰器例子

def my_decorator(func):
    def wrapper():
        print("函数调用前")
        func()
        print("函数调用后")
    return wrapper

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

say_hello()

在这个例子中，我们定义了一个装饰器 my_decorator，它接受一个函数 func 作为参数，并返回一个 wrapper 函数。在调用 say_hello 时，实际上是调用 wrapper 函数，这个函数在调用 func 之前和之后分别打印了一些信息。

更复杂的装饰器

带参数的装饰器

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数调用前")
        result = func(*args, **kwargs)
        print("函数调用后")
        return result
    return wrapper

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

greet("Alice")

在这个例子中，wrapper 函数接受任意数量的位置参数和关键字参数，并在调用 func 之前和之后打印信息。

多重装饰器示例
def decorator1(func):
    def wrapper():
        print("装饰器1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("装饰器2")
        func()
    return wrapper

@decorator1
@decorator2
def say_hello():
    print("Hello!")

say_hello()

这个例子会输出：

类方法和装饰器

类方法装饰器
def my_decorator(func):
    def wrapper(self, *args, **kwargs):
        print("Before method call")
        result = func(self, *args, **kwargs)
        print("After method call")
        return result
    return wrapper

class MyClass:
    @my_decorator
    def say_hello(self, name):
        print(f"Hello, {name}")

obj = MyClass()
obj.say_hello("Alice")

在这个例子中，my_decorator 被应用于 MyClass 的 say_hello 方法。

一、基本概念

在 Python 中，@ 符号通常用于函数定义之前，它被称为"装饰器"。一个最简单的例子如下:

@print
def say_hello():
    print("Hello， world!")

say_hello()

当我们运行这段代码时，输出将是:

<function say_hello at 0x7f6a1c0c8940>

这是怎么回事?原来，@print 其实是将 say_hello 函数"装饰"或"包装"了一层 print 函数。换句话说，say_hello = print(say_hello) 被隐式地执行了。

二、工作原理

现在让我们更深入地探讨一下装饰器的内部机制。装饰器的工作原理可以概括为以下几个步骤:

  1. 定义装饰器函数

  2. 将装饰器应用于目标函数

  3. 在运行时替换目标函数

让我们通过一个例子来演示这个过程:

def uppercase(func):
    def wrapper(*args， **kwargs):
        result = func(*args， **kwargs)
        return result.upper()
    return wrapper

@uppercase
def say_hello(name):
    return f"hello， {name}"

print(say_hello("Alice"))  # HELLO， ALICE

  1. 定义装饰器函数 uppercase。这个函数接受一个函数 func 作为参数，并返回一个新的函数 wrapper。

  2. 使用 @uppercase 语法将 uppercase 装饰器应用于 say_hello 函数。这实际上是将 say_hello 函数传递给 uppercase 函数，并将返回值重新赋值给 say_hello。

  3. 当我们调用 say_hello("Alice") 时，实际上调用的是 wrapper 函数，而不是原始的 say_hello 函数。wrapper 函数会调用原始的 say_hello 函数，并对其返回值进行大写转换。

通过这个过程，我们成功地在不改变 say_hello 函数本身的情况下，扩展了它的功能。这就是装饰器的核心机制。

三、带参数的装饰器

有时，我们可能需要为装饰器添加参数。这可以通过嵌套装饰器来实现:

def repeat(n):
    def decorator(func):
        def wrapper(*args， **kwargs):
            result = func(*args， **kwargs)
            return result * n
        return wrapper
    return decorator

@repeat(3)
def say_hello(name):
    return f"hello， {name}"

print(say_hello("Alice"))  # hello， Alice hello， Alice hello， Alice

在这个例子中，repeat 函数是一个"装饰器工厂"，它返回一个装饰器函数 decorator。decorator 函数接受原始函数 func 作为参数，并返回一个新的 wrapper 函数。wrapper 函数在内部调用 func，并将其返回值重复 n 次。

通过 @repeat(3) 语法，我们将 say_hello 函数"装饰"到了 repeat(3) 中，从而使得 say_hello 函数的返回值被重复 3 次。

装饰器在实际项目中的巧妙应用

一、 日志记录器

目标：自动记录函数调用信息。

from datetime import datetime

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"{datetime.now()} - Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{datetime.now()} - Finished {func.__name__}")
        return result
    return wrapper

@log_decorator
def say_hello(name):
    return f"Hello, {name}"

print(say_hello("World"))

这段代码就像是给函数装了个小尾巴，自动告诉我们它何时被叫醒，何时完成任务。

二、性能测试

用途：测量函数执行时间。

import time

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

@timer_decorator
def slow_function():
    time.sleep(1)

slow_function()

这个装饰器是性能优化的得力助手，帮你找出代码中的“慢跑者”。

三、 参数验证

应用场景：确保输入参数符合要求。

def positive_number_decorator(func):
    def wrapper(number):
        if number < 0:
            raise ValueError("Number must be positive.")
        return func(number)
    return wrapper

@positive_number_decorator
def square(number):
    return number ** 2

print(square(5))  # 正确
# print(square(-5))  # 将抛出异常

它像门卫一样，只允许符合条件的数字通过。

四、 缓存结果

优点：加速重复计算。

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n <= 1:
       return n
    else:
       return (fibonacci(n-1) + fibonacci(n-2))

print(fibonacci(30))  # 计算一次，下次直接返回结果

对于耗时的计算，缓存简直是神来之笔，大大提升了效率。

五、权限检查

场景：在Web应用中检查用户权限。

def admin_required(func):
    def wrapper(user):
        if user.role != 'admin':
            return "Access denied!"
        return func(user)
    return wrapper

@admin_required
def delete_user(user):
    return f"Deleted user {user.username}"

print(delete_user(User(role='user')))  # Access denied!

装饰器是实施访问控制的简洁方式。

六、计数统计

功能：跟踪函数调用次数。

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0

    def __call__(self, *args, **kwargs):
        self.calls += 1
        return self.func(*args, **kwargs)

@CountCalls
def greet():
    return "Hi there!"

print(greet())  # Hi there!
print(f"Called {greet.calls} times")  # 看看调用了几次

简单而强大，适合监控函数的活跃度。

七、异常处理

作用：统一处理函数异常。

def exception_handler(func):
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"Error in {func.__name__}: {e}")
    return wrapper

@exception_handler
def risky_business():
    return 1 / 0

risky_business()  # 优雅地捕获并显示异常

它让程序更加健壮，不怕小错误搞砸一切。

八、参数默认值设定

好处：灵活设置默认参数，增加函数灵活性。

def with_default_value(default):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if 'value' not in kwargs:
                kwargs['value'] = default
            return func(*args, **kwargs)
        return wrapper
    return decorator

@with_default_value("Hello")
def greet_with_value(value):
    return value

print(greet_with_value())  # 使用默认值
print(greet_with_value("World"))  # 自定义值

这样的装饰器让你的函数更加用户友好。

九、时间限制

适用：防止函数运行过久。

import signal

class TimeoutException(Exception):
    pass

def timeout(seconds):
    def decorator(func):
        def wrapper(*args, **kwargs):
            def handler(signum, frame):
                raise TimeoutException(f"Function {func.__name__} timed out after {seconds} seconds")
            signal.signal(signal.SIGALRM, handler)
            signal.alarm(seconds)
            try:
                result = func(*args, **kwargs)
            finally:
                signal.alarm(0)  # Disable alarm
            return result
        return wrapper
    return decorator

@timeout(3)
def slow_computation():
    import time
    time.sleep(4)

try:
    print(slow_computation())
except TimeoutException as e:
    print(e)

对于可能无限期运行的任务，这是个生命线。

十、类方法转换

应用：在类中轻松实现静态方法或类方法。

def class_method_decorator(func):
    def wrapper(cls, *args, **kwargs):
        return func(cls, *args, **kwargs)
    return classmethod(wrapper)

class MyClass:
    @class_method_decorator
    def say_hello(cls, name):
        return f"{cls.__name__} says Hello, {name}"

print(MyClass.say_hello("World"))  # 类方法的优雅应用

它让你在类设计上更加灵活，无需直接修改类定义。

进阶技巧与实战建议

一、嵌套装饰器

嵌套装饰器允许你组合多个装饰器的功能，为函数添加多重特性。比如，结合日志记录和性能测试：

@log_decorator
@timer_decorator
def complex_operation():
    # 某些复杂的计算
    pass

这样，你可以在一个函数上同时实现日志记录和时间测量。

二、参数化的装饰器

有时，你可能需要根据不同的情况调整装饰器的行为，这就是参数化装饰器的用武之地：

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hi():
    print("Hi!")

say_hi()  # 输出 "Hi!" 三次

三、 避免过度使用

虽然装饰器很强大，但过度使用会使代码难以理解和维护。确保每个装饰器都有明确且必要的用途。

四、文档字符串

为你的装饰器添加文档字符串，说明其用途和使用方法，提高代码的可读性和可维护性。

五、调试友好

在装饰器中加入适当的日志或打印语句，帮助调试时追踪函数调用流程。

实战案例分析

假设你正在开发一个API服务，其中需要对请求数据进行验证、计时响应时间和异常处理。你可以设计如下装饰器组合：

from flask import Flask, request
app = Flask(__name__)

@validate_request_data  # 假设这是验证请求数据的装饰器
@timer_decorator
@exception_handler
def handle_request():
    data = request.json
    # 处理逻辑
    return "Request processed successfully."

@app.route('/api', methods=['POST'])
def api_endpoint():
    return handle_request()

if __name__ == "__main__":
    app.run(debug=True)

在这个例子中，装饰器帮助我们以模块化的方式实现了请求处理的核心逻辑，使得代码既干净又功能丰富。

结语

掌握装饰器意味着打开了Python编程的一个新世界。

道不贱卖，法不轻传
关注
  • 13
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值