ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python-装饰器（Decorator）详解 [打印本页]

作者: 饭宝 时间: 2024-12-18 21:10
标题: Python-装饰器（Decorator）详解

在python中，函数是一等公民，意味着函数可以像其他对象一样被赋值、通报参数、作为返回值等。装饰器的根本语法是使用@符号将一个函数作为参数通报给另一个函数（即装饰器）。被装饰的函数在被调用时，实际上会实验装饰器函数返回的新函数‌。简朴来说，装饰器就是一个返回函数的函数。使用轻便，直接在函数定义上方加上 @decorator 语法糖。

1、 装饰器的根本概念

装饰器是为相识耦代码的逻辑、进步代码的复用性，并且让函数和类的活动在不修改其原始代码的前提下得以扩展。能有效地将某些附加活动抽象出来，使得主业务逻辑（比方函数自己）保持轻便和专注。装饰器本质上是一个担当函数作为参数并返回一个新函数的函数。它常用于：

在函数实验前后添加额外的活动。
修改函数的输入或输出。
为函数增加一些元数据。

装饰器的应用场景非常广泛，比方：日记记录、权限检查、性能计时、缓存等。装饰器的引入可以办理以下几个问题：

代码复用：装饰器可以将某些跨多个函数或类的功能（如日记、权限校验、缓存等）提取出来，以便于复用，制止重复代码。

增强代码的可维护性：装饰器使得附加功能与主功能分离，从而使代码更清晰，容易明白与维护。通过装饰器，修改或增加功能时无需修改原有函数或类的实现。

关注点分离（Separation of Concerns）：装饰器让你可以将不同的功能分开处理，将与业务逻辑无关的操作（如日记记录、性能监控等）从核心业务代码中剥离出来。

机动性和扩展性：使用装饰器可以机动地震态修改函数或方法的活动，而无需修改函数自己的代码。

2、 装饰器的使用

2.1 根本结构

最简朴的装饰器形式如下：

def decorator(func):
def wrapper():
print("Before function call")
func() # 调用原函数
print("After function call")
return wrapper
# 使用装饰器
@decorator
def say_hello():
print("Hello!")
# 调用装饰后的函数
say_hello()

复制代码

解释：

decorator 是一个装饰器函数，它吸收一个函数 func 作为参数。
wrapper 是一个新的函数，它在调用原函数 func() 之前和之后添加了自定义的活动。
@decorator 语法实际上是 say_hello = decorator(say_hello)，即用装饰器修改 say_hello 函数。

输出：

Before function call

Hello!

After function call

2.2 带参数的装饰器

装饰器可以担当参数。为了让装饰器支持带参数的函数，我们必要在 wrapper 函数中使用 *args 和 **kwargs 来通报参数。

示例：

def decorator(func):
def wrapper(*args, **kwargs):
print("Before function call")
result = func(*args, **kwargs)
print("After function call")
return result
return wrapper
@decorator
def add(a, b):
return a + b
result = add(3, 5)
print("Result:", result)

复制代码

解释：

wrapper 使用 *args 和 **kwargs 通报给被装饰函数，如许它就可以处理带有任意参数的函数。
在 wrapper 中，原函数 func(*args, **kwargs) 被调用，并且它的结果被返回。

输出：

Before function call

After function callResult: 8

2.3 装饰器的嵌套

装饰器可以嵌套使用，即一个函数可以同时被多个装饰器修饰。

示例：多个装饰器

def decorator1(func):
def wrapper(*args, **kwargs):
print("Decorator 1 - Before function call")
result = func(*args, **kwargs)
print("Decorator 1 - After function call")
return result
return wrapper
def decorator2(func):
def wrapper(*args, **kwargs):
print("Decorator 2 - Before function call")
result = func(*args, **kwargs)
print("Decorator 2 - After function call")
return result
return wrapper
@decorator1
@decorator2
def say_hello():
print("Hello!")
say_hello()

复制代码

解释：

装饰器的次序是从下到上的，即 @decorator2 起首应用，然后是 @decorator1。
调用 say_hello() 时，会先实验 decorator2，然后是 decorator1。

输出：

Decorator 2 - Before function call

Decorator 1 - Before function call

Hello!

Decorator 1 - After function call

Decorator 2 - After function call

2.4 使用 functools.wraps 保持原函数的元数据

当我们使用装饰器时，装饰器内部的 wrapper 函数会替代原始函数。这意味着原函数的名称、文档字符串（docstring）等信息会丢失。为了制止这种情况，可以使用 functools.wraps 来保持原函数的元数据。

示例：使用 functools.wraps

import functools
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print("Before function call")
result = func(*args, **kwargs)
print("After function call")
return result
return wrapper
@decorator
def say_hello():
"""This is the say_hello function."""
print("Hello!")
print(say_hello.__name__) # 输出：say_hello
print(say_hello.__doc__) # 输出：This is the say_hello function.

复制代码

解释：

@functools.wraps(func) 保证了装饰器不改变原函数的名称、文档字符串等元数据。
如果没有使用 wraps，则 say_hello.__name__ 会返回 wrapper，而不是 say_hello。

2.5 带参数的装饰器

有时我们大概盼望为装饰器通报参数（比方动态调整装饰器的活动）。为了实现这一点，我们必要使用三层嵌套函数。

示例：

def decorator_with_args(arg):
def decorator(func):
def wrapper(*args, **kwargs):
print(f"Decorator argument: {arg}")
return func(*args, **kwargs)
return wrapper
return decorator
@decorator_with_args("Hello")
def greet(name):
print(f"Greetings, {name}!")
greet("Alice")

复制代码

解释：

decorator_with_args 是一个担当参数的装饰器，它返回一个装饰器函数 decorator。
decorator 是实际的装饰器，它担当一个函数 func，并在 wrapper 函数中添加新的功能。
@decorator_with_args("Hello") 等价于 greet = decorator_with_args("Hello")(greet)。

输出：

Decorator argument: Hello

Greetings, Alice!

2.6 类方法和静态方法的装饰器

在类中使用装饰器时，必要注意装饰器的作用对象（类方法、实例方法、静态方法）。对于实例方法，装饰器会多一个 self 参数，对于类方法会有 cls 参数。

示例：装饰器作用于实例方法

class MyClass:
def decorator(func):
def wrapper(self, *args, **kwargs):
print("Before calling instance method")
result = func(self, *args, **kwargs)
print("After calling instance method")
return result
return wrapper
@decorator
def greet(self, name):
print(f"Hello, {name}!")
obj = MyClass()
obj.greet("Alice")

复制代码

示例：装饰器作用于类方法和静态方法

class MyClass:
@staticmethod
def decorator(func):
def wrapper(*args, **kwargs):
print("Before calling static method")
result = func(*args, **kwargs)
print("After calling static method")
return result
return wrapper
@decorator
@staticmethod
def greet(name):
print(f"Hello, {name}!")
MyClass.greet("Alice")

复制代码

3、python内置装饰器

常见的有：

@staticmethod - 用于定义静态方法。
@classmethod - 用于定义类方法。
@property - 将方法转化为属性（getter）。
@functools.lru_cache - 用于缓存函数结果，提拔性能。
@functools.wraps - 保留被装饰函数的元数据。
@abstractmethod - 定义抽象方法。
@property.setter - 为属性添加 setter 方法。
@property.deleter - 为属性添加 deleter 方法。

3.1 @staticmethod

@staticmethod 装饰器用于将一个方法定义为静态方法。静态方法不必要访问实例 (self) 或类 (cls)，它通常用于一些与类自己干系但不必要访问实例属性或方法的功能。

示例：

class MyClass:
@staticmethod
def greet(name):
print(f"Hello, {name}!")
# 静态方法不需要实例化类
MyClass.greet("Alice")

复制代码

输出：

Hello, Alice!

3.2 @classmethod

@classmethod 装饰器用于将方法定义为类方法。类方法吸收类自己作为第一个参数（通常命名为 cls），而不是实例。它通常用于操作类的属性或提供一些与类自己干系的功能。

示例：

class MyClass:
count = 0
@classmethod
def increment_count(cls):
cls.count += 1
print(f"Count: {cls.count}")
MyClass.increment_count() # 调用类方法

复制代码

输出：

Count: 1

3.3 @property

@property 装饰器用于将方法变为属性，这意味着该方法的调用方式就像访问属性一样，而不必要显式调用方法。常用于定义只读属性，大概为属性添加 getter 和 setter 方法。

示例：

class Circle:
def __init__(self, radius):
self._radius = radius
@property
def radius(self):
return self._radius
@property
def area(self):
return 3.14 * self._radius ** 2
c = Circle(5)
print(c.radius) # 直接访问属性
print(c.area) # 直接访问属性

复制代码

输出：

78.5

3.4 @functools.lru_cache

@lru_cache 是 functools 模块提供的一个装饰器，用于对函数的结果举行缓存。对于相同的参数，lru_cache 会返回缓存中的结果，从而制止重复计算，提拔函数的服从。LRU 代表 "Least Recently Used"（最少使用）。

示例：

import functools
@functools.lru_cache(maxsize=None)
def fibonacci(n):
if n < 2:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(35))
#@lru_cache 将自动缓存 fibonacci 函数的结果，避免重复计算，提高性能。

复制代码

3.5 @functools.wraps

@wraps 是 functools 模块中的一个装饰器，用于确保被装饰函数的元数据（如函数名、文档字符串等）在装饰后保持不变。当我们编写装饰器时，通常会使用 @wraps 来制止装饰器修改原函数的名称和文档字符串。

示例：

import functools
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print("Before function call")
return func(*args, **kwargs)
return wrapper
@decorator
def greet(name):
"""This is the greet function"""
print(f"Hello, {name}!")
print(greet.__name__) # 输出：greet
print(greet.__doc__) # 输出：This is the greet function

复制代码

输出：

Before function call

Hello, Alice!

@functools.wraps 保证了 greet 函数的名称和文档字符串没有被 wrapper 函数覆盖。

3.6 @abstractmethod

@abstractmethod 是 abc 模块提供的装饰器，用于声明一个方法为抽象方法。抽象方法不能直接在基类中实现，而必须在子类中实现。它通常用于定义抽象基类（ABC，Abstract Base Classes）。

示例：

from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
# 创建实例时，必须实现抽象方法
circle = Circle(5)
print(circle.area())

复制代码

输出：

78.5

3.7 @property.setter

@property.setter 装饰器用于给 @property 装饰器定义的属性添加 setter 方法。通过 setter 方法，可以控制属性值的设置。

示例：

class Circle:
def __init__(self, radius):
self._radius = radius
@property
def radius(self):
return self._radius
@radius.setter
def radius(self, value):
if value <= 0:
raise ValueError("Radius must be positive.")
self._radius = value
circle = Circle(5)
print(circle.radius) # 访问属性
circle.radius = 10 # 设置属性
print(circle.radius) # 访问更新后的属性

复制代码

输出：

3.8 @property.deleter

@property.deleter 装饰器用于定义删除属性的方法，允许通过 del 删除对象的属性。

示例：

class Circle:
def __init__(self, radius):
self._radius = radius
@property
def radius(self):
return self._radius
@radius.deleter
def radius(self):
print("Deleting radius")
del self._radius
circle = Circle(5)
print(circle.radius) # 访问属性
del circle.radius # 删除属性

复制代码

输出：

Deleting radius

3.9 @staticmethod 与 @classmethod 的组合使用

有时我们会将 @staticmethod 和 @classmethod 与其他装饰器结合使用。比方，可以在类方法中使用 @classmethod 与 @staticmethod 组合，在方法中实验类和实例的操作。

4、装饰器的实际作用示例

以下是一些装饰器常见的应用场景以及它们如何影响代码活动。

4.1 日记记录

假设你必要为多个函数添加日记记录功能，可以通过装饰器来制止重复编写日记记录代码。

def log_decorator(func):
def wrapper(*args, **kwargs):
print(f"Calling function {func.__name__} with arguments {args} and keyword arguments {kwargs}")
result = func(*args, **kwargs)
print(f"Function {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(1, 2)
multiply(3, 4)

复制代码

输出：

Calling function add with arguments (1, 2) and keyword arguments {}

Function add returned 3

Calling function multiply with arguments (3, 4) and keyword arguments {}

Function multiply returned 12

装饰器使得日记记录功能从业务逻辑中分离开来，你只必要为函数加上 @log_decorator 装饰器，而不必要在每个函数中重复编写日记干系代码。

4.2 性能监控

如果你盼望为多个函数监控实验时间，可以通过装饰器轻松实现：

import time
def time_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} took {end_time - start_time} seconds to execute")
return result
return wrapper
@time_decorator
def slow_function():
time.sleep(2)
@time_decorator
def fast_function():
time.sleep(0.5)
slow_function()
fast_function()

复制代码

输出：

Function slow_function took 2.002345085144043 seconds to execute

Function fast_function took 0.5001745223999023 seconds to execute

装饰器主动记录了函数的实验时间，制止了在每个函数内部手动写 time.time() 计算实验时间的代码。

4.3 权限验证

在 web 开发中，经常必要在处理请求之前验证用户的权限。这时可以使用装饰器来为多个视图函数或 API 接口加上权限检查。

def permission_required(func):
def wrapper(*args, **kwargs):
if not has_permission():
raise PermissionError("You do not have permission to access this resource.")
return func(*args, **kwargs)
return wrapper
def has_permission():
# 假设检查某个用户是否有权限
return False
@permission_required
def sensitive_data():
return "This is sensitive data."
try:
sensitive_data()
except PermissionError as e:
print(e)

复制代码

输出：

You do not have permission to access this resource.

装饰器为 sensitive_data 函数增加了权限检查逻辑。如许，后续所有必要权限验证的函数都可以通过添加 @permission_required 来使用该功能。

4.4 缓存

常见的缓存装饰器可以缓存函数的返回值，制止重复计算：

from functools import lru_cache
@lru_cache(maxsize=None) # 使用内置的缓存装饰器
def expensive_function(x):
print(f"Calculating {x}...")
return x * 2
print(expensive_function(4)) # 计算并缓存结果
print(expensive_function(4)) # 从缓存中获取结果

复制代码

输出：

Calculating 4...

第一次调用时计算并缓存，第二次调用直接返回缓存结果，节省了计算时间。

装饰器是 Python 中的一种用于修改函数或方法活动的高级特性，功能强大且机动，这里例举了一些装饰器的原理、应用和代码示例。感兴趣的小伙伴欢迎留言进一步探究。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)