【Python进阶】Python中的自定义装饰器：打造可重用的函数修饰

一、Python编程与设计模式简介

1.1 Python语言特点与应用领域

Python以其独特的设计理念和丰富的生态系统在全球范围内广受欢迎。其特点主要体现在以下几个方面：

1.1.1 语法简洁性与可读性

Python强调代码的易读性和简洁性，通过强制缩进和减少冗余符号，使得程序更接近自然语言，易于理解和维护。例如，相较于其他语言，Python中的循环和条件语句更为直观：

# Python 中的 for 循环示例

for i in range(10):

print(i)

# 其他语言可能需要更繁琐的语法实现相同功能1.1.2 动态类型与高级数据结构

Python采用动态类型系统，变量无需预先声明类型，这极大地提升了开发效率。同时，Python内置了丰富的数据结构，如列表、元组、字典和集合，它们都具有高效的操作性能。例如：

# 创建并操作列表

fruits = ['apple', 'banana', 'cherry']

fruits.append('date')

print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'date']

# 使用字典存储键值对

person = {'name': 'Alice', 'age': 25, 'job': 'Engineer'}

print(person['name'])  # 输出: 'Alice'1.1.3 面向对象与函数式编程范式

Python支持面向对象编程（OOP），允许开发者定义类和对象，实现继承、封装和多态。此外，Python也具备强大的函数式编程能力，如支持高阶函数、匿名函数（lambda表达式）以及迭代器和生成器等特性。下面是一个简单的类定义和匿名函数的例子：

# 定义一个简单的类

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def introduce(self):

return f"My name is {self.name} and I am {self.age} years old."

# 使用匿名函数

addition_lambda = lambda x, y: x + y

result = addition_lambda(3, 5)

print(result)  # 输出: 81.2 设计模式的重要性

设计模式是解决软件设计中常见问题的最佳实践，它能够显著提高代码复用率，保证软件质量，并简化复杂系统的维护。

1.2.1 代码复用与模块化设计

通过设计模式，我们可以将通用的解决方案抽象为独立模块或组件，从而实现代码复用。例如，在Python中，工厂模式可以用来根据需求动态创建不同类型的对象：

from abc import ABC, abstractmethod

# 抽象产品类

class Animal(ABC):

@abstractmethod

def make_sound(self):

pass

# 工厂类

class AnimalFactory:

@staticmethod

def create_animal(animal_type):

if animal_type == "dog":

return Dog()

elif animal_type == "cat":

return Cat()

# 具体产品类

class Dog(Animal):

def make_sound(self):

return "Woof!"

class Cat(Animal):

def make_sound(self):

return "Meow!"

# 使用工厂创建动物对象

animal = AnimalFactory.create_animal("dog")

print(animal.make_sound())  # 输出: Woof!1.2.2 提高软件质量和可维护性

设计模式鼓励良好的编码习惯，使代码更加灵活、健壮和易于维护。比如，单例模式确保在整个应用程序中只有一个类的实例，有助于统一资源管理和状态共享。

1.2.3 解耦复杂系统

通过适配器、代理、桥接等设计模式，可以有效地解耦复杂的系统，使得各部分之间的交互变得简单且易于扩展。例如，适配器模式可以把不兼容接口的对象转换成客户希望的接口：

class OldLibraryAPI:

def legacy_method(self):

return "This comes from an old library."

# 适配器类，提供新接口

class NewLibraryAdapter:

def __init__(self):

self.old_api = OldLibraryAPI()

def modern_method(self):

return self.old_api.legacy_method() + " (adapted for new system)"

new_system = NewLibraryAdapter()

print(new_system.modern_method())  # 输出: This comes from an old library. (adapted for new system)

通过上述例子和介绍，我们已经初步领略了Python语言的特点和设计模式的重要作用。随着后续章节的深入探讨，我们将看到如何在Python中运用装饰器这一重要设计模式，以实现代码的可重用性和功能性增强。

二、函数式编程基础与装饰器概念

2.1 函数作为一等公民

在Python中，函数被视为一等公民，这意味着函数可以像其他数据类型一样被赋值给变量、作为参数传递给其他函数，甚至可以从函数中返回。这种特性为装饰器的设计奠定了基础。

2.1.1 高阶函数与闭包

高阶函数是指接受函数作为参数或返回函数的函数。例如，Python内置的map()、filter()和reduce()都是高阶函数的典型代表。下面是一个利用高阶函数实现数值列表平方的简单示例：

def square(x):

return x ** 2

numbers = [1, 2, 3, 4]

squared_numbers = map(square, numbers)

print(list(squared_numbers))  # 输出: [1, 4, 9, 16]

闭包是另一个关键概念，它是一种特殊的函数，它可以记住并访问在其外部定义的变量。即使这些变量在闭包被调用时已经脱离了它们原本的作用域，闭包仍然可以访问它们。下面展示了一个用于创建计数器的闭包：

def counter():

count = 0

def increment():

nonlocal count

count += 1

return count

return increment

counter_func = counter()

print(counter_func())  # 输出: 1

print(counter_func())  # 输出: 22.1.2 递归与匿名函数（lambda表达式）

递归是函数直接或间接地调用自身的过程，常用于处理分治问题。例如，计算阶乘可以使用递归方式实现：

def factorial(n):

if n == 0 or n == 1:

return 1

else:

return n * factorial(n - 1)

print(factorial(5))  # 输出: 120

匿名函数（lambda表达式）则允许快速定义简单的、一次性使用的函数。下面是一个使用lambda表达式排序数组的例子：

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]

sorted_numbers = sorted(numbers, key=lambda x: x % 2 != 0)  # 按奇偶性排序

print(sorted_numbers)  # 输出: [2, 4, 6, 3, 3, 5, 5, 1, 1, 9]2.2 Python装饰器初探2.2.1 装饰器的基本概念

装饰器本质上是一个接收函数作为参数，并返回新函数的高阶函数。装饰器的主要目的是在不修改原有函数代码的基础上，为其添加额外的功能或行为。

def simple_decorator(func):

def wrapper(*args, **kwargs):

print("Before function call.")

result = func(*args, **kwargs)

print("After function call.")

return result

return wrapper

@simple_decorator

def say_hello(name):

print(f"Hello, {name}!")

say_hello("Alice")  # 输出：

# Before function call.

# Hello, Alice!

# After function call.2.2.2 @符号的使用与语法糖

在Python中，装饰器通常通过@decorator_name的形式来使用，这是一种语法糖，实际上是对函数进行如下调用的简写：

def decorated_function():

...

decorated_function = decorator(decorated_function)2.2.3 基础装饰器实例演示

下面是一个日志装饰器的基础实现，它会在函数执行前后打印相关信息：

import time

def log_decorator(func):

def wrapper(*args, **kwargs):

start_time = time.time()

print(f"{func.__name__} started at {time.ctime(start_time)}")

result = func(*args, **kwargs)

end_time = time.time()

duration = end_time - start_time

print(f"{func.__name__} ended at {time.ctime(end_time)}, took {duration:.2f} seconds.")

return result

return wrapper

@log_decorator

def process_data(data):

time.sleep(1)  # 模拟耗时操作

print(f"Processing data: {data}")

process_data("Some data")  # 输出类似：

# process_data started at ...

# Processing data: Some data

# process_data ended at ..., took X.XX seconds.

至此，我们已从函数式编程基础出发，引出了装饰器的概念及其基本实现方式。装饰器不仅体现了函数是一等公民的理念，而且展示了Python的强大之处——能够在不改变原有函数主体的情况下，通过装饰器增加额外的行为和功能。随着后续章节的深入，我们将继续探索装饰器的内部工作机制、不同类型装饰器的编写和高级应用场景。

三、深入理解Python装饰器的工作机制

3.1 装饰器的本质：函数封装与嵌套

3.1.1 装饰器的“包装”过程

装饰器的核心机制在于对原始函数进行“包装”，即将一个函数作为输入，并返回一个新的函数。这个新函数会执行一些额外的操作，然后再调用原始函数。这个过程类似于给原函数包裹上一层外壳，但核心功能依然由原函数实现。

考虑下面的装饰器实现，它在原函数调用前后分别打印消息：

def simple_decorator(original_function):

def wrapper(*args, **kwargs):

print("Before calling the original function.")

result = original_function(*args, **kwargs)

print("After calling the original function.")

return result

return wrapper

@simple_decorator

def greet(name):

print(f"Hello, {name}!")

greet("Alice")  # 输出：

# Before calling the original function.

# Hello, Alice!

# After calling the original function.

在这里，wrapper函数就是装饰器为greet函数创造的新外壳，它保存了对原始函数的引用，并在执行额外操作后调用了原函数。

3.1.2 原函数引用与functools.wraps()的作用

当装饰器对原函数进行包装时，如果不采取特殊措施，原函数的一些元信息（如名字、文档字符串等）可能会丢失。为了保留这些元信息，Python的functools模块提供了wraps函数，它可以帮助装饰器正确地保持原函数的身份。

import functools

def preserve_info_decorator(original_function):

@functools.wraps(original_function)

def wrapper(*args, **kwargs):

print("Preserving info while decorating.")

return original_function(*args, **kwargs)

return wrapper

@preserve_info_decorator

def add(a, b):

"""Adds two numbers."""

return a + b

print(add.__name__)  # 输出："add"

print(add.__doc__)   # 输出："Adds two numbers."

在这个例子中，使用functools.wraps(original_function)装饰wrapper函数，确保了原函数add的元信息得到保留。

3.2 无参装饰器的编写与实践

3.2.1 实现常见的功能增强装饰器3.2.1.1 日志记录装饰器

下面是一个简单的日志记录装饰器，它在调用原函数前后记录日志信息：

import logging

def log_decorator(original_function):

@functools.wraps(original_function)

def wrapper(*args, **kwargs):

logging.info(f"Calling function '{original_function.__name__}' with args {args} and kwargs {kwargs}.")

result = original_function(*args, **kwargs)

logging.info(f"Function '{original_function.__name__}' returned {result}.")

return result

return wrapper

@log_decorator

def calculate_average(numbers):

return sum(numbers) / len(numbers)

calculate_average([1, 2, 3, 4, 5])

此装饰器将在调用calculate_average函数时自动记录日志。

3.2.1.2 性能分析装饰器

这里展示一个计算函数执行时间的装饰器：

import time

def timing_decorator(original_function):

@functools.wraps(original_function)

def wrapper(*args, **kwargs):

start_time = time.time()

result = original_function(*args, **kwargs)

end_time = time.time()

execution_time = end_time - start_time

print(f"Function '{original_function.__name__}' executed in {execution_time:.6f} seconds.")

return result

return wrapper

@timing_decorator

def fibonacci(n):

if n <= 1:

return n

else:

return fibonacci(n-1) + fibonacci(n-2)

fibonacci(10)

该装饰器可以精确测量fibonacci函数或其他任何被装饰函数的执行时间。

3.2.1.3 权限校验装饰器

权限校验装饰器可以检查用户是否具有执行特定操作的权限：

def permission_decorator(permission_required):

def decorator(original_function):

@functools.wraps(original_function)

def wrapper(user, *args, **kwargs):

if user.has_permission(permission_required):

return original_function(user, *args, **kwargs)

else:

raise PermissionError(f"User lacks required permission: {permission_required}")

return wrapper

return decorator

class User:

def __init__(self, permissions):

self.permissions = permissions

def has_permission(self, perm):

return perm in self.permissions

@permission_decorator("edit_user")

def edit_profile(user, new_data):

print(f"Editing profile of user {user} with new data: {new_data}")

user = User(["view_profile", "edit_user"])

edit_profile(user, {"name": "New Name"})

在这个例子中，只有当用户具有指定的权限时，才能成功执行edit_profile函数。

3.3 带参数的装饰器及其应用场景

3.3.1 使用函数工厂创建有参装饰器

对于需要传入参数的装饰器，我们可以创建一个装饰器工厂函数，根据不同的参数生成不同功能的装饰器：

def cache_decorator(ttl=60):  # ttl指缓存有效时间（秒）

def decorator(original_function):

cache = {}

@functools.wraps(original_function)

def wrapper(*args, **kwargs):

key = str(args) + str(kwargs)

if key not in cache or time.time() - cache[key][0] > ttl:

cache[key] = (time.time(), original_function(*args, **kwargs))

return cache[key][1]

return wrapper

return decorator

@cache_decorator(ttl=30)

def expensive_computation(a, b):

# 假设这是一个耗时较长的计算

time.sleep(1)

return a * b

print(expensive_computation(2, 3))  # 第一次调用执行计算

print(expensive_computation(2, 3))  # 在ttl时间内再次调用，从缓存获取结果3.3.2 示例：动态设置缓存策略

上面的cache_decorator就是一个带参数的装饰器示例，它可以根据传入的缓存有效期参数动态调整缓存策略，提高了函数的执行效率。

四、装饰器进阶技巧与最佳实践

4.1 多层装饰器的顺序与组合

4.1.1 装饰器间的依赖与优先级

在Python中，装饰器可以叠加使用，形成多层装饰器。每层装饰器都会依次“包裹”住被装饰的函数，形成一种洋葱模型。当多个装饰器应用于同一个函数时，执行顺序遵循从内到外的原则，即最内层的装饰器最先执行，最外层的装饰器最后执行。例如：

def decorator1(func):

def wrapper():

print("Decorator 1 before")

func()

print("Decorator 1 after")

return wrapper

def decorator2(func):

def wrapper():

print("Decorator 2 before")

func()

print("Decorator 2 after")

return wrapper

@decorator1

@decorator2

def my_function():

print("Original Function")

my_function()

运行这段代码时，输出将是：

Decorator 2 before

Decorator 1 before

Original Function

Decorator 1 after

Decorator 2 after4.1.2 使用functools.wraps保持元信息完整性

当装饰器层层叠加时，若未使用functools.wraps，原始函数的元信息（如名称、文档字符串等）可能会被最外层装饰器所覆盖。为了避免这种情况，每个装饰器都应该使用functools.wraps来保留原始函数的元信息：

import functools

def decorator1(func):

@functools.wraps(func)

def wrapper():

print("Decorator 1 logic")

return func()

return wrapper

def decorator2(func):

@functools.wraps(func)

def wrapper():

print("Decorator 2 logic")

return func()

return wrapper

@decorator1

@decorator2

def my_function():

"""Original function docstring"""

print("Original Function")

print(my_function.__name__)  # 输出："my_function"

print(my_function.__doc__)   # 输出："Original function docstring"4.2 类装饰器与方法装饰器4.2.1 类装饰器的定义与使用

类装饰器可以用来装饰整个类，而非单个函数。类装饰器通常在类定义之后立即执行，并返回一个新的类。下面是一个简单的类装饰器，用于统计类实例的创建数量：

def class_counter(cls):

instances = 0

def wrapper(*args, **kwargs):

nonlocal instances

instances += 1

obj = cls(*args, **kwargs)

obj.instance_number = instances

return obj

wrapper.instances_created = 0

return wrapper

@class_counter

class MyClass:

def __init__(self, name):

self.name = name

obj1 = MyClass("Object 1")

obj2 = MyClass("Object 2")

print(obj1.instance_number)  # 输出：1

print(obj2.instance_number)  # 输出：2

print(MyClass.instances_created)  # 输出：24.2.2 对象方法与类方法的装饰

装饰器同样可以用于装饰类的方法。对于类方法，可以通过装饰classmethod或staticmethod来达到目的。例如，下面是一个装饰器，用于追踪类方法的调用次数：

def method_counter(method):

def wrapper(*args, **kwargs):

wrapper.calls += 1

return method(*args, **kwargs)

wrapper.calls = 0

return wrapper

class MyClass:

@method_counter

def my_method(self):

print("Method called")

obj = MyClass()

obj.my_method()

obj.my_method()

print(MyClass.my_method.calls)  # 输出：24.3 使用装饰器实现AOP（面向切面编程）4.3.1 AOP的基本概念与优势

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过分离横切关注点（如日志、权限检查、异常处理等）来改善代码的模块化程度。AOP让开发者能在不影响主业务逻辑的前提下，方便地在各个模块中添加附加行为。

4.3.2 利用装饰器实现AOP案例分析

例如，假设我们的应用中需要在每个HTTP请求开始和结束时打印日志，可以通过装饰器来实现这一横切关注点：

def http_request_logger(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

print("Starting HTTP request...")

response = func(*args, **kwargs)

print("Finished HTTP request.")

return response

return wrapper

@app.route('/api/some_endpoint')

@http_request_logger

def some_endpoint_handler(request_data):

# 主要业务逻辑

process_request(request_data)

return jsonify({"status": "success"})

此处，http_request_logger装饰器就是一个典型的AOP实现，它在一个通用的位置处理了所有请求的日志记录，而无需在每个处理函数中重复相同的代码。通过这种方式，装饰器在Python中充当了实现AOP的关键角色，增强了代码的可读性和可维护性。

五、装饰器在实际项目中的应用案例

5.1 Web框架中的路由装饰器

5.1.1 Flask/Django中的URL映射装饰器

在Flask和Django这样的Python Web框架中，装饰器广泛用于URL路由映射。例如，在Flask中，@app.route装饰器非常直观地将URL路径映射到相应的视图函数：

from flask import Flask

app = Flask(__name__)

@app.route('/')

def index():

return "Hello, World!"

@app.route('/users/<username>')

def user_profile(username):

return f"Welcome to the profile page of {username}"

if __name__ == '__main__':

app.run()

在这个例子中，@app.route装饰器把根路径'/'和'/users/'分别映射到了index和user_profile两个函数。其中，是一个动态路由参数，会被捕获并传递给user_profile函数。

5.1.2 数据验证与权限控制装饰器

Web应用中经常需要对请求的数据进行验证，或者对用户的权限进行校验。装饰器在这种情况下就显得尤为重要，可以用来封装这些共性逻辑。例如，下面是一个简单的权限验证装饰器：

def login_required(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

if not g.user.is_authenticated:  # 假设g.user是从全局上下文中获取的当前登录用户

return redirect(url_for('login'))  # 未登录则重定向至登录页面

return func(*args, **kwargs)

return wrapper

@app.route('/admin')

@login_required

def admin_panel():

return "Welcome to the Admin Panel!"5.2 数据库操作与事务管理装饰器5.2.1 SQLAlchemy中的事务装饰器

在SQLAlchemy这类ORM框架中，装饰器可以用来管理数据库事务，确保一系列操作要么全部成功，要么全部回滚。以下是一个简单的事务管理装饰器：

from sqlalchemy.exc import SQLAlchemyError

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)  # 假设engine是已配置好的数据库引擎

def transactional(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

session = Session()

try:

result = func(session, *args, **kwargs)

session.commit()

except SQLAlchemyError as e:

session.rollback()

raise e

finally:

session.close()

return result

return wrapper

@transactional

def update_records(session, id_list, new_value):

for id in id_list:

record = session.query(MyModel).get(id)

record.some_field = new_value

# 所有更新操作都在一个事务中完成5.2.2 数据库连接池优化装饰器

在并发环境下，合理管理数据库连接池至关重要。装饰器可以用来自动处理连接获取和释放，避免资源浪费。尽管在许多库中已经内建了连接池管理，但自行实现一个装饰器也能加深对装饰器在资源管理上的应用理解：

import psycopg2.pool

db_pool = psycopg2.pool.SimpleConnectionPool(1, 10, database="my_db", user="user", password="pass")

def with_db_connection(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

connection = db_pool.getconn()

try:

result = func(connection, *args, **kwargs)

finally:

db_pool.putconn(connection)

return result

return wrapper

@with_db_connection

def query_database(connection, sql_query):

cursor = connection.cursor()

cursor.execute(sql_query)

return cursor.fetchall()

通过这些实例，我们可以清楚地看到装饰器在实际项目中扮演着至关重要的角色，它们不仅帮助我们更好地组织代码，还增强了应用的安全性和性能。无论是Web框架中的路由映射、数据验证和权限控制，还是数据库操作与事务管理，装饰器都是提高代码可读性、可维护性及灵活性的有效工具。

六、装饰器相关拓展话题

6.1 Python标准库对装饰器的支持

6.1.1functools模块中的装饰器工具

Python的functools模块提供了许多实用的函数，专门用来辅助装饰器的编写。其中，functools.wraps是最常用的工具之一，它用于复制原函数的元信息，确保装饰器不会改变原函数的名称、文档字符串以及其他属性。

import functools

def debug_decorator(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

print(f"Calling function {func.__name__} with arguments: {args}, {kwargs}")

result = func(*args, **kwargs)

print(f"Function {func.__name__} returned: {result}")

return result

return wrapper

@debug_decorator

def add(a, b):

"""

Adds two numbers together.

"""

return a + b

print(add.__name__)  # 输出：add

print(add.__doc__)  # 输出：Adds two numbers together.

除此之外，functools模块还包括lru_cache（最近最少使用缓存）、singledispatch（单分派）等预置装饰器，为开发者提供便捷的工具箱。

6.1.2 使用contextlib实现上下文管理装饰器

Python的contextlib模块引入了一种编写上下文管理器的方式，可用于创建带有“with”语句的装饰器。例如，我们可以创建一个上下文管理装饰器用于自动关闭文件：

from contextlib import contextmanager

@contextmanager

def auto_close(file_obj):

try:

yield file_obj

finally:

file_obj.close()

@auto_close

def read_file(filename):

with open(filename, 'r') as file:

return file.read()

content = read_file('example.txt')

在此例中，auto_close装饰器确保无论read_file函数内部发生什么情况，打开的文件最终都能被正确关闭。

6.2 异步装饰器与协程支持

6.2.1 在异步编程中装饰器的角色

在Python的异步编程场景中，装饰器同样发挥着重要作用，尤其是结合asyncio库。例如，可以使用装饰器标记函数为异步函数（async def定义），也可以使用装饰器来调度任务或处理异步错误。

import asyncio

# 标记异步函数的装饰器

async def async_decorator(func):

async def wrapper(*args, **kwargs):

await asyncio.sleep(1)  # 模拟异步操作

return await func(*args, **kwargs)

return wrapper

@async_decorator

async def do_something_async():

print("Doing something asynchronously.")

loop = asyncio.get_event_loop()

future = asyncio.ensure_future(do_something_async())

loop.run_until_complete(future)6.2.2 asyncio库中的异步装饰器应用

import asyncio

# Python 3.7及以上版本

@asyncio.run

async def main():

print("Starting task...")

await asyncio.sleep(1)

print("Task completed.")

# Python 3.5及以上版本

@asyncio.timeout(2)

async def long_running_task():

await asyncio.sleep(3)  # 如果超过2秒还未完成，将会抛出异常

print("Task finished without timeout.")

通过深入研究Python标准库对装饰器的支持，我们可以看到装饰器在多种编程场景下的广泛应用，包括但不限于同步、异步环境下的函数增强、上下文管理以及错误处理等，大大提升了代码的可读性与可维护性。同时，了解并掌握这些装饰器工具，有助于开发者更好地驾驭Python异步编程，提高程序的性能与效率。

七、结语

7.1 装饰器在现代编程中的价值

7.1.1 提升代码组织结构

装饰器在现代编程中承担着关键的角色，尤其在Python中，它们能够帮助开发者实现代码的模块化与组织优化。通过装饰器，我们可以在不修改原有函数源码的基础上，透明地为其增添额外功能，如日志记录、性能监控、权限控制、缓存策略等。这种非侵入式的功能增强方式极大地提升了代码的整洁度和可维护性，使代码层次分明、逻辑清晰，便于团队协作与后期扩展。

7.1.2 促进软件工程原则的应用

装饰器充分体现了软件工程中的开闭原则（Open/Closed Principle），即软件实体应当对扩展开放，对修改关闭。使用装饰器，我们可以在不修改现有代码的基础上轻松扩展功能，降低了耦合度，增强了软件的适应性和稳定性。此外，装饰器还能协助实现诸如AOP（面向切面编程）等高级编程范式，使我们能够集中处理那些跨越多个模块和层级的横切关注点，如统一的异常处理、数据验证等。

7.2 探索更多Python高级特性与设计模式

7.2.1 继承与 mixin 类

装饰器并非唯一提升代码复用和组织结构的方式。在Python中，继承和mixin类也是两种重要的设计模式。通过继承，子类可以从父类继承属性和方法，实现代码复用。而mixin类则是一种纯粹为了复用而设计的类，它可以包含一组方法，然后被其他类通过多重继承合并。例如，一个logging mixin可以帮助多个类实现日志记录功能，而不必在每个类中单独实现：

class LoggingMixin:

def log(self, message):

print(f"[LOG] {message}")

class MyClass(LoggingMixin):

def __init__(self):

self.log("MyClass instance created.")

my_instance = MyClass()  # 输出：[LOG] MyClass instance created.7.2.2 插件系统与钩子函数

插件系统则是另一种基于装饰器或其他设计模式（如工厂模式）实现的可扩展架构，允许第三方或用户在不修改主程序源码的前提下添加新的功能模块。而在Python中，钩子函数也是一种常见的扩展机制，它允许在特定阶段（如初始化、清理等）执行额外操作。装饰器可以作为一种轻量级的钩子，特别是在Web框架中，用于在请求处理前后执行自定义逻辑。