请解释什么是Python装饰器，以及它有哪些应用场景

Python装饰器详解

1. 装饰器的定义和基本概念

Python装饰器（Decorator）是一种设计模式，它允许用户在不修改原有函数或类代码的情况下，动态地添加功能。装饰器本质上是一个Python函数，它接受一个函数作为参数，并返回一个新的函数。

装饰器提供了一种优雅的语法，使用@符号将装饰器应用到函数或方法上，使得代码更加简洁、可读。

2. 装饰器的工作原理

装饰器的工作原理基于Python中的闭包（Closure）和函数是一等公民的特性。闭包是指一个函数记住了它被创建时的环境。

--- title:装饰器工作原理 --- graph TD A["原始函数 func()"] --> B["装饰器 decorator()"] B --> C["内部函数 wrapper()"] C --> D["添加新功能"] D --> E["调用原始函数 func()"] E --> F["返回 wrapper 函数"] F --> G["被装饰后的新函数"]

当Python解释器遇到@decorator语法时，它会执行以下步骤：

将被装饰的函数作为参数传递给装饰器函数
装饰器函数定义一个内部函数（通常称为wrapper），这个内部函数会添加新的功能
内部函数调用原始函数并返回结果
装饰器函数返回这个内部函数
原始函数名现在指向这个新的内部函数

3. 装饰器的语法和使用方法

基本语法

# 定义装饰器
def decorator(func):
    def wrapper(*args, **kwargs):
        # 在调用原始函数前添加的功能
        print("Something is happening before the function is called.")
        
        # 调用原始函数
        result = func(*args, **kwargs)
        
        # 在调用原始函数后添加的功能
        print("Something is happening after the function is called.")
        
        return result
    return wrapper

# 使用装饰器
@decorator
def say_hello(name):
    print(f"Hello, {name}!")

# 调用被装饰的函数
say_hello("Alice")

等价的手动装饰方式

def say_hello(name):
    print(f"Hello, {name}!")

# 手动装饰，等价于使用@decorator语法
say_hello = decorator(say_hello)

# 调用被装饰的函数
say_hello("Alice")

带参数的装饰器

如果装饰器本身需要参数，我们需要再嵌套一层函数：

def repeat(num_times):
    def decorator_repeat(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator_repeat

@repeat(num_times=3)
def greet(name):
    print(f"Hello, {name}!")

greet("World")

4. 装饰器的应用场景

装饰器在Python中有广泛的应用场景，主要包括：

4.1 日志记录

记录函数的调用信息、参数和返回值。

def log(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned: {result}")
        return result
    return wrapper

@log
def add(a, b):
    return a + b

add(3, 5)

4.2 性能测试/计时

测量函数的执行时间。

import time

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

@timer
def slow_function():
    time.sleep(1)
    print("Function executed")

slow_function()

4.3 权限验证和访问控制

检查用户是否有权限执行某个函数。

def requires_permission(permission):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            if user.has_permission(permission):
                return func(user, *args, **kwargs)
            else:
                raise PermissionError(f"User lacks required permission: {permission}")
        return wrapper
    return decorator

class User:
    def __init__(self, permissions):
        self.permissions = permissions
    
    def has_permission(self, permission):
        return permission in self.permissions

@requires_permission("admin")
def delete_user(user, user_id):
    print(f"User {user_id} deleted")

admin = User(["admin", "editor"])
guest = User(["viewer"])

delete_user(admin, 123)  # 成功执行
delete_user(guest, 456)  # 抛出PermissionError

4.4 缓存/记忆化

缓存函数的结果，避免重复计算。

def memoize(func):
    cache = {}
    
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(35))  # 计算速度明显快于未使用缓存的版本

4.5 输入验证

验证函数的输入参数。

def validate_types(**type_annotations):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # 将位置参数转换为关键字参数
            bound_args = {}
            arg_names = list(func.__code__.co_varnames[:func.__code__.co_argcount])
            
            for i, arg in enumerate(args):
                if i < len(arg_names):
                    bound_args[arg_names[i]] = arg
            
            # 添加关键字参数
            bound_args.update(kwargs)
            
            # 验证参数类型
            for param_name, param_value in bound_args.items():
                if param_name in type_annotations:
                    expected_type = type_annotations[param_name]
                    if not isinstance(param_value, expected_type):
                        raise TypeError(f"Argument '{param_name}' must be of type {expected_type.__name__}")
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_types(x=int, y=int)
def add(x, y):
    return x + y

print(add(3, 5))      # 正常执行
print(add("3", "5"))  # 抛出TypeError

4.6 重试机制

在函数执行失败时自动重试。

import time

def retry(max_attempts, delay=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts == max_attempts:
                        raise e
                    print(f"Attempt {attempts} failed. Retrying in {delay} seconds...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=3, delay=2)
def unreliable_function():
    import random
    if random.random() < 0.7:  # 70%的概率失败
        raise ValueError("Random failure")
    return "Success"

print(unreliable_function())

4.7 上下文管理

为函数提供特定的上下文环境。

def with_context(context):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"Entering context: {context}")
            try:
                result = func(*args, **kwargs)
            finally:
                print(f"Exiting context: {context}")
            return result
        return wrapper
    return decorator

@with_context("database")
def query_database(query):
    print(f"Executing query: {query}")
    return "Query results"

query_database("SELECT * FROM users")

5. 常见的装饰器示例

5.1 Python内置装饰器

Python提供了一些内置装饰器：

@property: 将方法转换为属性
@staticmethod: 定义静态方法
@classmethod: 定义类方法
@functools.wraps: 保留被装饰函数的元信息

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 cannot be negative")
        self._radius = value
    
    @property
    def area(self):
        import math
        return math.pi * self._radius ** 2
    
    @staticmethod
    def from_diameter(diameter):
        return Circle(radius=diameter/2)
    
    @classmethod
    def unit_circle(cls):
        return cls(radius=1)

# 使用property装饰器
c = Circle(5)
print(c.radius)  # 访问属性
c.radius = 10   # 设置属性
print(c.area)    # 计算属性

# 使用staticmethod和classmethod
c2 = Circle.from_diameter(10)
c3 = Circle.unit_circle()

5.2 使用functools.wraps保留元信息

当使用装饰器时，原始函数的元信息（如函数名、文档字符串等）会被替换为包装函数的元信息。为了解决这个问题，可以使用functools.wraps装饰器。

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def greet(name):
    """Greet someone by their name."""
    return f"Hello, {name}!"

print(greet.__name__)  # 输出: greet
print(greet.__doc__)   # 输出: Greet someone by their name.

6. 装饰器的进阶用法

6.1 类装饰器

装饰器不仅可以用于函数，也可以用于类。

def add_method(cls):
    def new_method(self):
        return "This is a new method"
    
    cls.new_method = new_method
    return cls

@add_method
class MyClass:
    def existing_method(self):
        return "This is an existing method"

obj = MyClass()
print(obj.existing_method())  # 输出: This is an existing method
print(obj.new_method())       # 输出: This is a new method

6.2 多个装饰器的组合

可以为一个函数应用多个装饰器，执行顺序是从下到上（从内到外）。

def bold(func):
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

@bold
@italic
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  # 输出: <b><i>Hello, Alice!</i></b>

6.3 带状态的装饰器

装饰器可以带有状态，即可以记住一些信息。

def count_calls(func):
    def wrapper(*args, **kwargs):
        wrapper.call_count += 1
        print(f"Call {wrapper.call_count} of {func.__name__}")
        return func(*args, **kwargs)
    wrapper.call_count = 0
    return wrapper

@count_calls
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))
print(greet("Bob"))
print(f"Total calls: {greet.call_count}")

6.4 使用类实现装饰器

除了使用函数实现装饰器，还可以使用类实现装饰器。

class Timer:
    def __init__(self, func):
        self.func = func
        self.call_count = 0
    
    def __call__(self, *args, **kwargs):
        import time
        self.call_count += 1
        start_time = time.time()
        result = self.func(*args, **kwargs)
        end_time = time.time()
        print(f"{self.func.__name__} executed in {end_time - start_time:.4f} seconds")
        print(f"Total calls: {self.call_count}")
        return result

@Timer
def slow_function():
    time.sleep(1)
    return "Function completed"

print(slow_function())
print(slow_function())

总结

Python装饰器是一种强大的编程工具，它允许我们在不修改原始函数或类代码的情况下，动态地添加功能。装饰器基于闭包和函数是一等公民的特性，使用@语法提供了一种优雅的方式来扩展函数的行为。

装饰器的应用场景非常广泛，包括日志记录、性能测试、权限验证、缓存、输入验证、重试机制等。通过合理使用装饰器，我们可以使代码更加模块化、可读性更强，并遵循DRY（Don't Repeat Yourself）原则。

在实际开发中，我们应该充分利用Python内置的装饰器（如@property、@staticmethod、@classmethod等），并根据需要创建自定义装饰器来解决特定问题。同时，使用functools.wraps来保留被装饰函数的元信息是一个良好的实践。

参考文档：

account_tree

思维导图

Interview AiBoxInterview AiBox — 面试搭档

不只是准备，更是实时陪练

Interview AiBox 在面试过程中提供实时屏幕提示、AI 模拟面试和智能复盘，让你每一次回答都更有信心。

免费下载 Interview AiBoxdownload 查看价格方案sell

AI 助读

一键发送到常用 AI

Python装饰器是一种设计模式，允许在不修改原有函数代码的情况下动态添加功能。它本质上是一个函数，接受一个函数作为参数并返回一个新函数。装饰器基于闭包和函数是一等公民的特性，使用@符号提供优雅语法。应用场景包括日志记录、性能测试、权限验证、缓存、输入验证、重试机制等。Python内置装饰器有@property、@staticmethod、@classmethod等，使用functools.wraps可保留被装饰函数的元信息。装饰器使代码更模块化、可读性更强，遵循DRY原则。

智能总结

深度解读

考点定位

思路启发