python 20个接口自动化常用的装饰器脚本

📝 面试求职: 「面试试题小程序」 ,内容涵盖 测试基础、Linux操作系统、MySQL数据库、Web功能测试、接口测试、APPium移动端测试、Python知识、Selenium自动化测试相关、性能测试、性能测试、计算机网络知识、Jmeter、HR面试,命中率杠杠的。(大家刷起来…)

📝 职场经验干货:

软件测试工程师简历上如何编写个人信息(一周8个面试)

软件测试工程师简历上如何编写专业技能(一周8个面试)

软件测试工程师简历上如何编写项目经验(一周8个面试)

软件测试工程师简历上如何编写个人荣誉(一周8个面试)

软件测试行情分享(这些都不了解就别贸然冲了.)

软件测试面试重点,搞清楚这些轻松拿到年薪30W+

软件测试面试刷题小程序免费使用(永久使用)


文中装饰器涵盖了日志记录、性能计时、异常处理、缓存、重试机制、认证、参数验证、装饰器链组合、JSON响应格式化、请求限流、环境变量注入、响应时间监控、自定义头信息添加、数据转换、并发控制、分布式锁、API版本控制、安全审计、输入校验和输出过滤。

部分装饰器(如 distributed_lock_decorator)依赖于外部服务(如Redis),你需要确保在实际使用时安装并配置相应的服务。

对于某些复杂的装饰器(如 input_validation_decorator),你需要提供具体的校验逻辑或模式。

根据自身需要动手试一下吧‍

import functools
import time
import logging
import traceback
from typing import Callable, Any
# 设置基本的日志配置
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# 1. 日志记录装饰器​​​​​​​

def log_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        logging.info(f"Calling function {func.__name__} with args: {args}, kwargs: {kwargs}")
        try:
            result = func(*args, **kwargs)
            logging.info(f"Function {func.__name__} returned: {result}")
            return result
        except Exception as e:
            logging.error(f"Function {func.__name__} raised an exception: {e}")
            logging.error(traceback.format_exc())
            raise
    return wrapper
# 示例函数
@log_decorator
def add(x: int, y: int) -> int:
    return x + y
# 使用场景:当你想记录函数调用及其返回值时
# 输出结果:
# INFO:root:Calling function add with args: (3, 5), kwargs: {}
# INFO:root:Function add returned: 8

# 2. 性能计时装饰器​​​​​​​

def timing_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        logging.info(f"Function {func.__name__} took {end_time - start_time:.4f} seconds to execute")
        return result
    return wrapper
# 示例函数
@timing_decorator
def slow_function():
    time.sleep(2)
# 使用场景:当你想测量某个函数执行的时间时
# 输出结果:
# INFO:root:Function slow_function took 2.0003 seconds to execute

# 3. 异常处理装饰器​​​​​​​

def exception_handler_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        try:
            return func(*args, **kwargs)
        except Exception as e:
            logging.error(f"An error occurred in function {func.__name__}: {e}")
            logging.error(traceback.format_exc())
            return None
    return wrapper
# 示例函数
@exception_handler_decorator
def risky_function(divisor: int) -> float:
    return 10 / divisor
# 使用场景:当你想捕获并记录函数中的异常时
# 输出结果(当传入0时):
# ERROR:root:An error occurred in function risky_function: division by zero
# ERROR:root:Traceback (most recent call last):
#   File "decorators.py", line 46, in wrapper
#     return func(*args, **kwargs)
#   File "decorators.py", line 97, in risky_function
#     return 10 / divisor
# ZeroDivisionError: division by zero

# 4. 缓存结果装饰器​​​​​​​

def cache_results(func: Callable) -> Callable:
    cache = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        key = args + tuple(kwargs.items())
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    return wrapper
# 示例函数
@cache_results
def expensive_function(x: int) -> int:
    time.sleep(1)
    return x * x
# 使用场景:当你想缓存函数的结果以提高性能时
# 输出结果(第一次调用x=5时会有延迟,后续调用会立即返回)
# 第一次调用expensive_function(5)耗时约1秒
# 后续调用expensive_function(5)几乎立即返回

# 5. 重试机制装饰器​​​​​​​

def retry_decorator(max_retries: int = 3, delay: float = 1):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            attempts = 0
            while attempts < max_retries:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    logging.warning(f"Attempt {attempts}/{max_retries} failed for function {func.__name__}: {e}")
                    time.sleep(delay)
            logging.error(f"All retries failed for function {func.__name__}")
            raise
        return wrapper
    return decorator
# 示例函数
@retry_decorator(max_retries=3, delay=1)
def unstable_function():
    if random.choice([True, False]):
        raise Exception("Random failure")
    return "Success"
# 使用场景:当你希望在失败后自动重试某个函数时
# 输出结果(如果函数随机失败两次但最终成功):
# WARNING:root:Attempt 1/3 failed for function unstable_function: Random failure
# WARNING:root:Attempt 2/3 failed for function unstable_function: Random failure
# 'Success'

# 6. 认证检查装饰器​​​​​​​

def auth_required(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        token = kwargs.get('token')
        if not token or not validate_token(token):
            logging.error("Authentication required")
            raise PermissionError("Authentication required")
        return func(*args, **kwargs)
    return wrapper
def validate_token(token: str) -> bool:
    # 模拟令牌验证
    return token == "valid_token"
# 示例函数
@auth_required
def secure_function(data: str, token: str) -> str:
    return f"Processed data: {data}"
# 使用场景:当你需要确保只有经过认证的用户才能访问某个函数时
# 输出结果(当token有效时):
# 'Processed data: some_data'
# 输出结果(当token无效时):
# ERROR:root:Authentication required
# PermissionError: Authentication required

# 7. 参数验证装饰器​​​​​​​

def validate_params(param_names: list):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            for param_name in param_names:
                if param_name not in kwargs:
                    logging.error(f"Missing parameter: {param_name}")
                    raise ValueError(f"Missing parameter: {param_name}")
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@validate_params(['data'])
def process_data(**kwargs) -> str:
    return f"Processing data: {kwargs['data']}"
# 使用场景:当你需要确保函数接收到所有必需的参数时
# 输出结果(当传递了'data'参数时):
# 'Processing data: example_data'
# 输出结果(当未传递'data'参数时):
# ERROR:root:Missing parameter: data
# ValueError: Missing parameter: data

# 8. 装饰器链组合​​​​​​​

def combined_decorators(decorator_list: list):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            for dec in reversed(decorator_list):
                func = dec(func)
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@combined_decorators([log_decorator, timing_decorator, exception_handler_decorator])
def complex_function(x: int, y: int) -> int:
    return x / y
# 使用场景:当你需要在一个函数上应用多个装饰器时
# 输出结果(当y为0时):
# INFO:root:Calling function complex_function with args: (10, 0), kwargs: {}
# ERROR:root:An error occurred in function complex_function: division by zero
# ERROR:root:Traceback (most recent call last):
#   ...
# None
# 输出结果(当y不为0时):
# INFO:root:Calling function complex_function with args: (10, 2), kwargs: {}
# INFO:root:Function complex_function returned: 5.0
# INFO:root:Function complex_function took 0.0000 seconds to execute

# 9. JSON响应格式化装饰器​​​​​​​

def json_response_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> dict:
        result = func(*args, **kwargs)
        return {"status": "success", "data": result}
    return wrapper
# 示例函数
@json_response_decorator
def fetch_data() -> str:
    return "Sample Data"
# 使用场景:当你需要将函数的返回值格式化为JSON响应时
# 输出结果:
# {'status': 'success', 'data': 'Sample Data'}

# 10. 请求限流装饰器​​​​​​​

class RateLimiter:
    def __init__(self, rate_limit: int = 10, period: int = 60):
        self.rate_limit = rate_limit
        self.period = period
        self.requests = []
    def allow_request(self) -> bool:
        current_time = time.time()
        self.requests = [req for req in self.requests if current_time - req < self.period]
        if len(self.requests) < self.rate_limit:
            self.requests.append(current_time)
            return True
        return False
rate_limiter = RateLimiter(rate_limit=5, period=10)
def rate_limit_decorator(limiter: RateLimiter):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            if limiter.allow_request():
                return func(*args, **kwargs)
            else:
                logging.warning("Rate limit exceeded")
                raise RuntimeError("Rate limit exceeded")
        return wrapper
    return decorator
# 示例函数
@rate_limit_decorator(rate_limiter)
def limited_function():
    return "Allowed Request"
# 使用场景:当你需要限制某个函数的请求速率时
# 输出结果(在短时间内多次调用时):
# 'Allowed Request'
# 'Allowed Request'
# 'Allowed Request'
# 'Allowed Request'
# 'Allowed Request'
# WARNING:root:Rate limit exceeded
# RuntimeError: Rate limit exceeded

# 11. 环境变量注入装饰器​​​​​​​

import os
def inject_env_vars(env_var_names: list):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            env_vars = {var: os.getenv(var) for var in env_var_names}
            kwargs.update(env_vars)
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@inject_env_vars(['API_KEY'])
def use_api_key(api_key: str):
    return f"Using API Key: {api_key}"
# 使用场景:当你需要从环境变量中获取某些配置信息时
# 输出结果(假设环境变量API_KEY已设置为'secret_key'):
# 'Using API Key: secret_key'

# 12. 响应时间监控装饰器​​​​​​​

def response_time_monitoring_decorator(threshold: float):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            response_time = end_time - start_time
            if response_time > threshold:
                logging.warning(f"Response time for function {func.__name__} exceeded threshold: {response_time}s")
            return result
        return wrapper
    return decorator
# 示例函数
@response_time_monitoring_decorator(threshold=1)
def slow_response():
    time.sleep(2)
    return "Slow Response"
# 使用场景:当你需要监控某个函数的响应时间是否超过阈值时
# 输出结果:
# WARNING:root:Response time for function slow_response exceeded threshold: 2.0003s
# 'Slow Response'

# 13. 自定义头信息添加装饰器​​​​​​​

def add_custom_headers(headers: dict):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            existing_headers = kwargs.get('headers', {})
            updated_headers = {**existing_headers, **headers}
            kwargs['headers'] = updated_headers
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@add_custom_headers({'Authorization': 'Bearer token'})
def make_request(headers: dict):
    return headers
# 使用场景:当你需要向HTTP请求添加自定义头信息时
# 输出结果:
# {'Authorization': 'Bearer token'}

# 14. 数据转换装饰器​​​​​​​

def data_transformation_decorator(transform_func: Callable):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            transformed_args = transform_func(args)
            transformed_kwargs = transform_func(kwargs)
            return func(*transformed_args, **transformed_kwargs)
        return wrapper
    return decorator
def transform_example(data):
    # 示例数据转换函数
    return {k: v.upper() if isinstance(v, str) else v for k, v in data.items()}
# 示例函数
@data_transformation_decorator(transform_example)
def print_transformed_data(data: dict):
    return data
# 使用场景:当你需要对输入数据进行某种转换时
# 输出结果:
# {'NAME': 'JOHN', 'AGE': 30}

# 15. 并发控制装饰器​​​​​​​

import threading
def concurrency_control_decorator(max_concurrent: int):
    semaphore = threading.Semaphore(max_concurrent)
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            with semaphore:
                return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@concurrency_control_decorator(max_concurrent=3)
def concurrent_task(task_id: int):
    time.sleep(1)
    return f"Task {task_id} completed"
# 使用场景:当你需要限制同时运行的任务数量时
# 输出结果(多线程环境下,最多有3个任务同时运行)

# 16. 分布式锁装饰器​​​​​​​

from redis import Redis
redis_client = Redis()
def distributed_lock_decorator(lock_key: str, timeout: int = 10):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            lock_acquired = redis_client.setnx(lock_key, 1)
            if lock_acquired:
                redis_client.expire(lock_key, timeout)
                try:
                    return func(*args, **kwargs)
                finally:
                    redis_client.delete(lock_key)
            else:
                logging.warning(f"Distributed lock for {lock_key} already acquired")
                raise RuntimeError("Distributed lock already acquired")
        return wrapper
    return decorator
# 示例函数
@distributed_lock_decorator(lock_key='my_lock')
def critical_section():
    time.sleep(2)
    return "Critical Section Completed"
# 使用场景:当你需要确保同一时间只有一个进程或线程可以执行某个关键部分的代码时
# 输出结果(第一个调用成功,第二个调用失败):
# 'Critical Section Completed'
# WARNING:root:Distributed lock for my_lock already acquired
# RuntimeError: Distributed lock already acquired

# 17. API版本控制装饰器​​​​​​​

def api_version_control_decorator(required_version: str):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            version = kwargs.get('version')
            if version != required_version:
                logging.error(f"Incorrect API version: {version}. Required version: {required_version}")
                raise ValueError(f"Incorrect API version: {version}. Required version: {required_version}")
            return func(*args, **kwargs)
        return wrapper
    return decorator
# 示例函数
@api_version_control_decorator(required_version='v1')
def api_call(version: str):
    return "API Call Successful"
# 使用场景:当你需要确保API调用使用的版本正确时
# 输出结果(当version为'v1'时):
# 'API Call Successful'
# 输出结果(当version不是'v1'时):
# ERROR:root:Incorrect API version: v2. Required version: v1
# ValueError: Incorrect API version: v2. Required version: v1

# 18. 安全审计装饰器​​​​​​​

def security_audit_decorator(func: Callable) -> Callable:
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        audit_log = f"Audit Log - Function: {func.__name__}, Args: {args}, Kwargs: {kwargs}"
        logging.info(audit_log)
        result = func(*args, **kwargs)
        logging.info(f"Audit Log - Result: {result}")
        return result
    return wrapper
# 示例函数
@security_audit_decorator
def sensitive_operation(data: str):
    return f"Processed Sensitive Data: {data}"
# 使用场景:当你需要记录敏感操作的日志时
# 输出结果:
# INFO:root:Audit Log - Function: sensitive_operation, Args: (), Kwargs: {'data': 'secret'}
# INFO:root:Audit Log - Result: Processed Sensitive Data: secret

# 19. 输入校验装饰器​​​​​​​

def input_validation_decorator(schema: dict):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            validated_data = validate_input(schema, kwargs)
            return func(*args, **validated_data)
        return wrapper
    return decorator
def validate_input(schema: dict, data: dict) -> dict:
    # 示例输入校验函数
    for key, expected_type in schema.items():
        if key not in data or not isinstance(data[key], expected_type):
            raise ValueError(f"Invalid input for {key}. Expected type: {expected_type}")
    return data
# 示例函数
@input_validation_decorator({'name': str, 'age': int})
def create_user(name: str, age: int):
    return f"User created: {name}, Age: {age}"
# 使用场景:当你需要确保输入的数据类型正确时
# 输出结果(当输入符合要求时):
# 'User created: John, Age: 30'
# 输出结果(当输入不符合要求时):
# ValueError: Invalid input for age. Expected type:

# 20. 输出过滤装饰器​​​​​​​

def output_filtering_decorator(filter_func: Callable):
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            result = func(*args, **kwargs)
            filtered_result = filter_func(result)
            return filtered_result
        return wrapper
    return decorator
def filter_example(data):
    # 示例输出过滤函数
    return {k: v for k, v in data.items() if v is not None}
# 示例函数
@output_filtering_decorator(filter_example)
def get_filtered_data():
    return {"name": "John", "age": None, "city": "New York"}
# 使用场景:当你需要过滤掉输出中的某些值时
# 输出结果:
# {'name': 'John', 'city': 'New York'}
# 示例使用
if __name__ == "__main__":
    # 测试日志记录装饰器
    add(3, 5)
    # 测试性能计时装饰器
    slow_function()
    # 测试异常处理装饰器
    risky_function(0)
    # 测试缓存结果装饰器
    expensive_function(5)
    expensive_function(5)
    # 测试重试机制装饰器
    import random
    unstable_function()
    # 测试认证检查装饰器
    try:
        secure_function(data="some_data", token="invalid_token")
    except PermissionError as e:
        print(e)
    secure_function(data="some_data", token="valid_token")
    # 测试参数验证装饰器
    try:
        process_data(not_data="example_data")
    except ValueError as e:
        print(e)
    process_data(data="example_data")
    # 测试装饰器链组合
    complex_function(10, 2)
    # 测试JSON响应格式化装饰器
    print(fetch_data())
    # 测试请求限流装饰器
    for _ in range(6):
        try:
            print(limited_function())
        except RuntimeError as e:
            print(e)
    # 测试环境变量注入装饰器
    os.environ['API_KEY'] = 'secret_key'
    print(use_api_key())
    # 测试响应时间监控装饰器
    slow_response()
    # 测试自定义头信息添加装饰器
    print(make_request(headers={}))
    # 测试数据转换装饰器
    print(print_transformed_data(data={'name': 'john', 'age': 30}))
    # 测试并发控制装饰器
    threads = []
    for i in range(5):
        t = threading.Thread(target=concurrent_task, args=(i,))
        threads.append(t)
        t.start()
    for t in threads:
        t.join()
    # 测试分布式锁装饰器
    try:
        critical_section()
        critical_section()
    except RuntimeError as e:
        print(e)
    # 测试API版本控制装饰器
    try:
        api_call(version='v2')
    except ValueError as e:
        print(e)
    api_call(version='v1')
    # 测试安全审计装饰器
    sensitive_operation(data="secret")
    # 测试输入校验装饰器
    try:
        create_user(name="John", age="thirty")
    except ValueError as e:
        print(e)
    create_user(name="John", age=30)
    # 测试输出过滤装饰器
    print(get_filtered_data())‍

最后: 下方这份完整的软件测试视频教程已经整理上传完成,需要的朋友们可以自行领取【保证100%免费】

​​​

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值