掘金后端 ( ) • 2024-04-19 10:07

ChatGPT学习Python系列之Python装饰器

网上查询Python装饰器相关资料，质量层次不齐，通过问答形式利用ChatGPT3.5学习了Python装饰器相关的概念及示例，GPT给出的解答和示例代码质量非常高，总结如下。

1. 什么是python装饰器

Python的装饰器是一种功能强大的语法，允许在不修改原始函数代码的情况下，通过添加额外的功能来修改函数的行为。装饰器本质上是一个函数，它接受另一个函数作为参数，并返回一个新的函数，通常在内部对传入的函数进行一些处理或包装。

装饰器通常用于以下情况：

代码重用：可以在多个函数中使用相同的功能，而不需要重复编写代码。日志记录：可以添加日志记录功能，记录函数的调用和执行情况。性能调优：可以添加性能分析功能，跟踪函数的执行时间等。权限验证：可以添加权限验证功能，限制某些函数只能被特定用户或角色调用。

常见的Python装饰器包括：

@staticmethod：将方法转换为静态方法，使得该方法不需要访问实例的状态。
@classmethod：将方法转换为类方法，使得该方法可以访问类的状态而不是实例的状态。
@property：将方法转换为属性，使得可以像访问属性一样访问该方法，同时也可以使用@property.setter和@property.deleter定义属性的设置和删除操作。
@abstractmethod：用于定义抽象方法，该方法必须在子类中被实现。
@wraps：用于保留原始函数的元数据，如文档字符串、名称和参数信息等。
自定义装饰器：除了Python内置的装饰器外，你还可以编写自己的装饰器来实现特定的功能，比如日志记录、性能分析、权限验证等。

这些装饰器提供了灵活的方式来修改函数的行为，使得代码更加简洁、易读和可维护。你可以根据具体的需求选择合适的装饰器来实现所需的功能。

2. 常用Python装饰器及示例代码

1. @staticmethod

将方法转换为静态方法，使得该方法不需要访问实例的状态。

静态方法不会自动接受类或实例作为第一个参数。它类似于普通函数，但它在类的命名空间中定义。
静态方法不能访问类或实例的状态，因为它们没有参数来传递类或实例。
静态方法可以通过类直接调用，也可以通过实例调用。

示例1:

class Math:
    @staticmethod
    def add(x, y):
        return x + y

print(Math.add(2, 3))  # 输出: 5

示例2:

class MyClass:
    @staticmethod
    def static_method():
        return "I am a static method"

print(MyClass.static_method())  # 输出: I am a static method

2. @classmethod

将方法转换为类方法，使得该方法可以访问类的状态而不是实例的状态。

类方法是将方法绑定到类而不是实例的方法。它的第一个参数通常被命名为cls，用于表示类本身。
类方法可以访问类的属性和方法，因为它们通过参数cls传递了类本身。
类方法可以通过类直接调用，也可以通过实例调用。

示例1:

class Math:
    multiplier = 2

    @classmethod
    def multiply(cls, x):
        return x * cls.multiplier

print(Math.multiply(3))  # 输出: 6

示例2:

class MyClass:
    class_variable = "I am a class variable"

    @classmethod
    def class_method(cls):
        return cls.class_variable

print(MyClass.class_method())  # 输出: I am a class variable

类方法和静态方法区别说明:

类方法可以访问类的属性和方法，并且通过cls参数传递类本身；而静态方法不能访问类或实例的状态，它们更像是普通的函数。选择使用哪种方法取决于你的需求，如果需要访问类的属性和方法，应该使用类方法，否则使用静态方法。

3. @property

将方法转换为属性，使得可以像访问属性一样访问该方法，同时也可以使用@property.setter和@property.deleter定义属性的设置和删除操作。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        self._radius = value

circle = Circle(5)
print(circle.radius)  # 输出: 5
circle.radius = 7
print(circle.radius)  # 输出: 7

4. @abstractmethod

用于定义抽象方法，该方法必须在子类中被实现。

在 Python 中，抽象方法是一种特殊的方法，它没有具体的实现，而是在抽象基类（Abstract Base Class，ABC）中声明，并且必须在子类中被实现。Python 中的抽象方法通过 @abstractmethod 装饰器来定义。

抽象方法的作用是定义一个接口，规定了子类必须实现的方法，但不提供具体的实现。这样可以确保子类实现了特定的行为，从而保证了代码的一致性和可靠性。

示例1:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

rectangle = Rectangle(3, 4)
print(rectangle.area())  # 输出: 12

示例2:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

# 创建实例并调用抽象方法
dog = Dog()
cat = Cat()

print(dog.make_sound())  # 输出: Woof!
print(cat.make_sound())  # 输出: Meow!

在这个例子中，Animal 是一个抽象基类，其中定义了一个抽象方法 make_sound()，该方法没有具体的实现。Dog 和 Cat 类是 Animal 的子类，它们都实现了 make_sound() 方法。在子类中必须实现抽象方法，否则会抛出 TypeError 异常。这样可以确保所有的子类都具有相同的行为。

5. @wraps

functools.wraps 装饰器是 Python 标准库 functools 中的一个函数，用于保留被装饰函数的元数据，如函数名、文档字符串等。这在编写装饰器时非常有用，因为装饰器会替换原始函数，可能会导致丢失原始函数的一些重要信息。

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before the function call")
        result = func(*args, **kwargs)
        print("After the function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """A simple function that says hello"""
    print(f"Hello, {name}!")

say_hello("Alice")
print(say_hello.__name__)  # 输出: say_hello
print(say_hello.__doc__)   # 输出: A simple function that says hello

在这个示例中，my_decorator 装饰器装饰了 say_hello 函数，并在内部定义了一个 wrapper 函数。使用 @wraps(func) 装饰器确保了 wrapper 函数的元数据与原始函数 say_hello 保持一致。因此，调用 say_hello 函数后，你会发现其名称和文档字符串都没有变化。

示例代码返回如下：

Before the function call
Hello, Alice!
After the function call
say_hello
A simple function that says hello

示例代码说明：

装饰器函数 my_decorator 的定义：定义了 my_decorator 装饰器函数，但并没有立即执行。
被装饰函数 say_hello 的定义：定义了 say_hello 函数，并使用 @my_decorator 装饰器装饰了它。
say_hello 函数的调用：调用了 say_hello("Alice") 函数，实际上触发了装饰器函数 my_decorator 中的 wrapper 函数。
my_decorator 中的 wrapper 函数执行：在调用被装饰函数前，wrapper 函数先打印 "Before the function call"，然后执行被装饰函数 say_hello，再打印 "After the function call"。最后返回被装饰函数的返回值（如果有的话）。
被装饰函数 say_hello 的执行：被装饰函数 say_hello 执行了打印 "Hello, Alice!"。

总的执行顺序是先执行装饰器函数的定义，然后定义被装饰函数，接着调用被装饰函数时实际上执行了装饰器函数中的 wrapper 函数，最后执行被装饰函数的函数体。

6. 自定义装饰器

除了Python内置的装饰器外，你还可以编写自己的装饰器来实现特定的功能，比如日志记录、性能分析、权限验证等。

下面是一个自定义装饰器的示例代码，该装饰器用于记录函数的执行时间：

示例1:

import time
from functools import wraps

def measure_time(func):
    @wraps(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:.4f} seconds.")
        return result
    return wrapper

@measure_time
def my_function(n):
    total = 0
    for i in range(n):
        total += i
    return total

result = my_function(1000000)
print("Result:", result)

在这个例子中，measure_time是一个自定义装饰器，它接受一个函数作为参数，并返回一个包装函数wrapper。wrapper函数记录了函数执行的开始时间和结束时间，然后计算执行时间，并打印出来。@wraps(func)装饰器用于保留原始函数的元数据，比如函数名和文档字符串。

my_function函数是一个简单的示例函数，它对一个很大的范围进行求和操作。通过在my_function前面添加@measure_time装饰器，可以实现对该函数执行时间的测量。调用my_function时，会自动执行装饰器中的代码，并打印出函数执行时间。

示例2:

def log_execution_time(func):
    def wrapper(*args, **kwargs):
        import time
        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:.4f} seconds.")
        return result
    return wrapper

@log_execution_time
def my_function(n):
    total = 0
    for i in range(n):
        total += i
    return total

result = my_function(1000000)
print("Result:", result)

wraps 装饰器和自定义装饰器之间的区别在于它们的功能和使用场景：

功能：
- wraps 装饰器是 Python 标准库中 functools 模块提供的一个函数，用于在定义装饰器时保留被装饰函数的元数据，如函数名、文档字符串等。它主要用于解决装饰器覆盖原始函数的问题。
- 自定义装饰器是程序员根据实际需求编写的装饰器函数，它可以实现各种不同的功能，如日志记录、性能分析、权限验证等。
使用场景：
- wraps 装饰器通常用于编写装饰器时，为了保留被装饰函数的元数据，防止装饰器破坏原始函数的属性和行为。
- 自定义装饰器则根据具体的需求来编写，可以实现各种自定义的功能，例如添加额外的逻辑、修改函数的行为等。

虽然 wraps 装饰器也是一种自定义装饰器，但它的主要目的是保持被装饰函数的元数据，而不是实现特定的功能。因此，在编写自定义装饰器时，可能会同时使用 wraps 装饰器来保留被装饰函数的元数据。

本文由mdnice多平台发布