Interview AiBox logo
Interview AiBox
Interview AiBox logo

Interview AiBox 实时 AI 助手，让你自信应答每一场面试

download免费下载
进阶•local_fire_department12 次面试•更新于 2025-08-25•account_tree思维导图

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

lightbulb

题型摘要

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

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语法时，它会执行以下步骤：

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

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 AiBox logo

Interview AiBox — 面试搭档

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

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

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

AI 助读

一键发送到常用 AI

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

智能总结

深度解读

考点定位

思路启发

Scira AI
页面速览
ChatGPT
要点总结
Perplexity
来源检索
Claude
结构化解读
Google AI
关键信息
Grok
观点提炼
T3 Chat
对话拆解
auto_awesome

相关题目

请做一个自我介绍

自我介绍是面试的开场环节，应控制在2-3分钟内，包含基本信息、教育背景、项目经验、个人特点、求职动机和结束语。关键在于突出与岗位相关的技能和经验，用具体事例支撑能力，展现对公司和岗位的了解。表达时应保持自信、简洁明了，避免背诵简历内容或过度夸张。准备过程包括分析岗位需求、梳理个人经历、找出匹配点、构建框架、撰写初稿、修改润色、模拟练习和最终定稿。

arrow_forward

如何编写有效的测试用例？请分享你的方法和经验。

编写有效的测试用例是软件测试的核心工作。有效测试用例应具备准确性、清晰性、可执行性、可重复性、独立性、完备性和可追踪性。常用测试用例设计方法包括等价类划分法、边界值分析法、决策表法、状态转换法和场景法。测试用例设计流程包括需求分析、确定测试范围、识别测试条件、选择测试方法、设计测试用例、评审优化、执行测试、分析结果和维护用例库。最佳实践包括遵循需求驱动、保持用例独立性、注重可维护性、平衡广度深度、持续优化。测试用例管理工具如TestRail、Zephyr等可提高测试效率。从用户角度思考、关注边界异常、利用历史数据、重视非功能测试和与开发团队合作是重要的经验分享。

arrow_forward

请谈谈你对测试开发工程师这个角色的理解

测试开发工程师是介于传统测试工程师和开发工程师之间的角色，核心定位是"质量赋能者"。他们通过编写代码、工具和框架来提高测试效率和质量，职责包括测试框架开发、自动化测试实现、测试策略制定、质量度量分析等。测试开发工程师需要具备"T型"知识结构，既有编程能力、测试专业知识，又有系统设计能力和DevOps实践。在软件开发生命周期的各个阶段都能发挥重要作用，从需求分析到线上运维。职业发展路径包括技术专家、管理、产品和转型等多个方向。未来，测试开发工程师将面临AI赋能、质量保障前置、全流程监控等趋势，需要不断拓展技术能力，成为连接开发、测试和运维的桥梁。

arrow_forward

如果让你为一个登录功能设计测试用例，你会考虑哪些方面和场景？

登录功能测试用例设计需全面考虑功能、界面、安全、性能、兼容性、异常和用户体验七个方面。功能测试验证基本功能是否正常，包括正向和反向测试；界面测试确保布局样式符合设计；安全测试检查漏洞防护；性能测试评估负载表现；兼容性测试验证多环境适配；异常测试检验异常处理能力；用户体验测试评估易用性。通过这七个方面的全面测试，可确保登录功能的质量和可靠性。

arrow_forward

排查慢SQL的常见原因有哪些？如何优化？

慢SQL是指执行时间超过阈值的SQL查询，会导致用户体验下降、系统资源消耗增加等问题。常见原因包括索引问题(缺少索引、索引失效)、查询语句问题(SELECT *、复杂JOIN)、数据库设计问题(表结构不合理、数据类型不当)、配置问题(参数配置不当、硬件资源不足)以及数据量问题(数据量过大、分布不均)。排查方法包括慢查询日志分析、执行计划分析、性能分析工具和监控告警。优化策略涵盖索引优化(合理创建索引、遵循索引设计原则)、SQL语句优化(避免SELECT *、优化JOIN和分页)、数据库设计优化(表拆分、适当冗余)、配置优化(内存和连接参数调整)以及架构优化(读写分离、缓存、分库分表)。预防慢SQL需要在开发、部署和运维各阶段遵循最佳实践，并借助工具支持。

arrow_forward

阅读状态

阅读时长

7 分钟

阅读进度

4%

章节：23 · 已读：0

当前章节： 1. 装饰器的定义和基本概念

最近更新：2025-08-25

本页目录

1. 装饰器的定义和基本概念
2. 装饰器的工作原理
3. 装饰器的语法和使用方法
基本语法
等价的手动装饰方式
带参数的装饰器
4. 装饰器的应用场景
4.1 日志记录
4.2 性能测试/计时
4.3 权限验证和访问控制
4.4 缓存/记忆化
4.5 输入验证
4.6 重试机制
4.7 上下文管理
5. 常见的装饰器示例
5.1 Python内置装饰器
5.2 使用functools.wraps保留元信息
6. 装饰器的进阶用法
6.1 类装饰器
6.2 多个装饰器的组合
6.3 带状态的装饰器
6.4 使用类实现装饰器
总结
Interview AiBox logo

Interview AiBox

AI 面试实时助手

面试中屏幕实时显示参考回答，帮你打磨表达。

免费下载download

分享题目

复制链接，或一键分享到常用平台

外部分享