8个内置Python装饰器，让代码更优雅

开发者可以使用装饰器修改函数的行为，而无需更改其源代码。这提供了一种简洁而灵活的方法来增强和

Python以其清晰可读的语法，是一种广泛使用的高级编程语言。Python旨在易于使用，强调简洁性和降低程序维护成本。它配备了一个广泛的库，减少了开发者从头编写代码的需求，从而提高了开发者的生产力。Python的一个强大特性——装饰器，正是提升代码优雅性的因素之一。

什么是Python装饰器？

在Python中，装饰器是一种允许您在不更改函数核心逻辑的情况下修改其行为的函数。它以另一个函数作为参数，并返回具有扩展功能的函数。通过这种方式，您可以使用装饰器为现有函数添加一些额外的逻辑，从而仅用几行代码就能提高可重用性。在本文中，我们将探讨八个内置的Python装饰器，这些装饰器可以帮助您编写更优雅和可维护的代码。

1. @atexit.register

@atexit.register装饰器用于注册一个在程序终止时执行的函数。无论程序是由于正常执行还是意外错误即将退出，此函数均可用于执行任何任务。

示例：

import atexit

# 注册 exit_handler 函数
@atexit.register
def exit_handler():
    print("Exiting the program. Cleanup tasks can be performed here.")

# 程序的其余部分
def main():
    print("Inside the main function.")
    # 你的程序逻辑在这里。

if __name__ == "__main__":
    main()

输出：

Inside the main function.
Exiting the program. Cleanup tasks can be performed here.

在上述实现中，@atexit.register被提到函数定义的上方。它将exit_handler()函数定义为退出函数。基本上，这意味着每当程序到达终止点时，无论是正常执行还是由于意外错误导致的提前退出，exit_handler()函数都会被调用。

2. @dataclasses.dataclass

@dataclasses.dataclass是一个强大的装饰器，用于自动生成类的常见特殊方法，如“__init__”、“__repr__”等。它通过消除为初始化和比较类的实例而编写样板方法的需要，帮助您编写更清晰、更简洁的代码。它还可以通过确保在代码库中一致地实现常见的特殊方法来帮助防止错误。

示例：

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int


point = Point(x=3, y=2)
# 打印对象
print(point)

# 检查两个对象的相等性
point1 = Point(x=1, y=2)
point2 = Point(x=1, y=2)
print(point1 == point2)

输出：

Point(x=3, y=2)
True

@dataclass装饰器，应用于Point类定义之上，指示Python利用默认行为生成特殊方法。这自动创建了__init__方法，该方法在对象实例化时初始化类属性，如x和y。因此，可以在不需要显式编码的情况下构建像point这样的实例。此外，负责提供对象字符串表示的__repr__方法也被自动调整。这确保了当一个对象（如point）被打印时，它能产生一个清晰有序的表示，如输出所示：Point(x=3, y=2)。此外，两个实例point1和point2之间的相等比较（==）产生True。这很值得注意，因为默认情况下，Python根据内存位置检查相等性。然而，在dataclass对象的上下文中，相等性是通过它们所包含的数据来确定的。这是因为@dataclass装饰器生成了一个__eq__方法，该方法检查对象内数据的相等性，而不是检查相同的内存位置。

3. @enum.unique

@enum.unique装饰器存在于enum模块中，用于确保枚举的所有成员的值是唯一的。这有助于防止意外创建具有相同值的多个枚举成员，从而避免混淆和错误。如果发现重复值，将引发ValueError。

示例：

from enum import Enum, unique

@unique
class VehicleType(Enum):
    CAR = 1
    TRUCK = 2
    MOTORCYCLE = 3
    BUS = 4

# 尝试创建具有重复值的枚举将引发ValueError
try:
    @unique
    class DuplicateVehicleType(Enum):
        CAR = 1
        TRUCK = 2
        MOTORCYCLE = 3
        # BUS和MOTORCYCLE具有重复值
        BUS = 3
except ValueError as e:
    print(f"Error: {e}")

输出：

Error: duplicate values found in : BUS -> MOTORCYCLE

在上述实现中，“BUS”和“MOTORCYCLE”具有相同的值“3”。因此，@unique装饰器引发了一个ValueError，并显示一条消息，指示找到重复值。您既不能多次使用相同的键，也不能为不同成员分配相同的值。通过这种方式，它有助于防止为多个枚举成员分配重复值。

4. @partial

partial装饰器是一个强大的工具，用于创建偏函数。偏函数允许您预设原始函数的一些参数，并生成一个新函数，其中这些参数已经填入。

示例：

from functools import partial

# 原始函数
def power(base, exponent):
    return base ** exponent

# 创建一个偏函数，将指数固定为2
square = partial(power, exponent=2)

# 使用偏函数
result = square(3)
print("Output:",result)

输出：

Output: 9

在上述实现中，我们有一个接受两个参数“base”和“exponent”的函数“power”，并返回base的指数幂的结果。我们使用原始函数创建了一个名为“square”的偏函数，其中指数预设为2。通过这种方式，我们可以使用partial装饰器扩展原始函数的功能。

5. @singledispatch

@singledispatch装饰器用于创建泛型函数。它允许您定义具有相同名称但不同参数类型的函数的不同实现。当您希望代码针对不同的数据类型表现出不同的行为时，它特别有用。

示例：

from functools import singledispatch

# 装饰器
@singledispatch
def display_info(arg):
    print(f"Generic: {arg}")

# 为不同类型注册专门的实现
@display_info.register(int)
def display_int(arg):
    print(f"Received an integer: {arg}")

@display_info.register(float)
def display_float(arg):
    print(f"Received a float: {arg}")

@display_info.register(str)
def display_str(arg):
    print(f"Received a string: {arg}")

@display_info.register(list)
def display_sequence(arg):
    print(f"Received a sequence: {arg}")

# 使用泛型函数处理不同类型
display_info(39)             
display_info(3.19)          
display_info("Hello World!")
display_info([2, 4, 6])

输出：

Received an integer: 39
Received a float: 3.19
Received a string: Hello World!
Received a sequence: [2, 4, 6]

在以上实现中，我们首先使用@singledispatch装饰器开发了泛型函数display_info()，然后分别注册了其对int、float、string和list的实现。输出显示了display_info()对不同数据类型的工作方式。

6. @classmethod

@classmethod是一个装饰器，用于在类中定义类方法。类方法绑定到类而不是类的对象。静态方法和类方法之间的主要区别在于它们与类状态的交互。类方法可以访问并修改类状态，而静态方法不能访问类状态并独立运行。

示例：

class Student:
    total_students = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Student.total_students += 1

    @classmethod
    def increment_total_students(cls):
        cls.total_students += 1
        print(f"Class method called. Total students now: {cls.total_students}")

# 创建类的实例
student1 = Student(name="Tom", age=20)
student2 = Student(name="Cruise", age=22)

# 调用类方法
Student.increment_total_students()  #Total students now: 3

# 访问类变量
print(f"Total students from student 1: {student1.total_students}")
print(f"Total students from student 2: {student2.total_students}")

输出：

Class method called. Total students now: 3
Total students from student 1: 3
Total students from student 2: 3

在上述实现中，Student类有total_students作为类变量。@classmethod装饰器用于定义increment_total_students()类方法以递增total_students变量。每当我们创建Student类的实例时，学生总数就增加一个。我们创建了两个类的实例，然后使用类方法将total_students变量修改为3，这也在类的实例中反映出来。

7. @staticmethod

@staticmethod装饰器用于在类中定义静态方法。静态方法是可以在不创建类的实例的情况下调用的方法。当方法不需要访问与对象相关的参数且更多与整个类相关时，通常使用静态方法。

示例：

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

    @staticmethod
    def subtract(x, y):
        return x - y

# 在不创建类实例的情况下使用静态方法
sum_result = MathOperations.add(5, 4)
difference_result = MathOperations.subtract(8, 3)

print("Sum:", sum_result)            
print("Difference:", difference_result)

输出：

Sum: 9
Difference: 5

在上述实现中，我们使用@staticmethod为类“MathOperations”定义了一个静态方法add()。我们将两个数字“4”和“5”相加，结果为“9”，而无需创建类的任何实例。同样，减去两个数字“8”和“3”得到“5”。这种方式可以生成静态方法来执行不需要实例状态的实用功能。

8. @property

@property装饰器用于定义类属性的getter方法。getter方法是返回属性值的方法。这些方法用于数据封装，指定谁可以访问类或实例的详细信息。

示例：

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

    @property
    def radius(self):
        # radius的getter方法。
        return self._radius

    @property
    def area(self):
        # area的getter方法。
        return 3.14 * self._radius**2

# 创建Circle类的实例
my_circle = Circle(radius=5)

# 使用@property装饰器访问属性
print("Radius:", my_circle.radius)          
print("Area:", my_circle.area)

输出：

Radius: 5
Area: 78.5

在上述实现中，类“Circle”有一个属性“radius”。我们使用@property设置了radius和area的getter方法。它为类的用户提供了一个干净且一致的接口来访问这些属性。

总结

本文重点介绍了一些最通用和功能强大的装饰器，您可以使用它们来使代码更加灵活和可读。这些装饰器允许您扩展原始函数的功能，使其更有条理，且不易出错。它们就像魔法触碰，使您的Python程序看起来整洁且运行顺畅。

理解Python装饰器：初学者指南与示例

每位开发者必知的15种代码生成提示技巧

引言提示工程对于有效的代码生成变得至关