def simple_decorator(func):
    def wrapper(*args, **kwargs):
        print("函數(shù)執(zhí)行前")
        result = func(*args, **kwargs)
        print("函數(shù)執(zhí)行后")
        return result
    return wrapper

@simple_decorator
def example_function():
    print("原始函數(shù)執(zhí)行")

@simple_decorator
def function():
    pass

def function():
    pass
function = simple_decorator(function)

@decorator(arg1, arg2)
def function():
    pass

def function():
    pass
function = decorator(arg1, arg2)(function)

from functools import wraps

def parametrized_decorator(param1, param2=None):
    # 第一層：接收裝飾器參數(shù)
    def decorator(func):
        # 第二層：接收被裝飾函數(shù)
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 第三層：實(shí)際包裝邏輯，可使用裝飾器參數(shù)
            print(f"使用參數(shù): {param1}, {param2}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

def flexible_decorator(func=None, *, optional_param=default_value):
    if func is None:
        # 被以@decorator()或@decorator(param=value)形式調(diào)用
        return lambda f: flexible_decorator(f, optional_param=optional_param)
    
    # 被以@decorator形式直接調(diào)用
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 使用optional_param控制行為
        return func(*args, **kwargs)
    return wrapper

from functools import wraps, partial

def logged(func=None, *, level='INFO', message=None):
    if func is None:
        # 返回部分應(yīng)用的裝飾器
        return partial(logged, level=level, message=message)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[{level}] {message or func.__name__}")
        return func(*args, **kwargs)
    return wrapper

def universal_decorator(*args, **kwargs):
    # 檢測調(diào)用方式
    if len(args) == 1 and callable(args[0]) and not kwargs:
        # @decorator 形式 - args[0]是被裝飾函數(shù)
        func = args[0]
        return decorator_with_defaults(func)
    else:
        # @decorator(...) 形式 - 返回真正的裝飾器
        return lambda func: decorator_with_params(func, *args, **kwargs)

def decorator_with_params(func, *dec_args, **dec_kwargs):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 使用dec_args和dec_kwargs
        return func(*args, **kwargs)
    return wrapper

def decorator_with_defaults(func):
    # 使用默認(rèn)參數(shù)的裝飾邏輯
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

from functools import wraps

def properly_wrapped_decorator(func=None, *, param=default):
    if func is None:
        return lambda f: properly_wrapped_decorator(f, param=param)
    
    @wraps(func)  # 保留函數(shù)名、文檔字符串等元數(shù)據(jù)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

import logging
from functools import wraps, partial

def logged(func=None, *, level=logging.INFO, name=None, message=None):
    """可配置的日志裝飾器"""
    if func is None:
        return partial(logged, level=level, name=name, message=message)
    
    logger = logging.getLogger(name or func.__module__)
    log_message = message or f"調(diào)用函數(shù) {func.__name__}"
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.log(level, f"開始 {log_message}")
        try:
            result = func(*args, **kwargs)
            logger.log(level, f"完成 {log_message}")
            return result
        except Exception as e:
            logger.error(f"{log_message} 失敗: {str(e)}")
            raise
    
    return wrapper

# 多種使用方式
@logged  # 使用默認(rèn)參數(shù)
def function1():
    pass

@logged(level=logging.DEBUG)  # 自定義日志級別
def function2():
    pass

@logged(level=logging.ERROR, message="重要操作")  # 完全自定義
def function3():
    pass

import time
from functools import wraps, partial

def retry(func=None, *, max_attempts=3, delay=1.0, backoff=2.0, exceptions=(Exception,)):
    """可配置的重試裝飾器"""
    if func is None:
        return partial(retry, max_attempts=max_attempts, delay=delay, 
                      backoff=backoff, exceptions=exceptions)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        last_exception = None
        current_delay = delay
        
        for attempt in range(1, max_attempts + 1):
            try:
                return func(*args, **kwargs)
            except exceptions as e:
                last_exception = e
                if attempt < max_attempts:
                    print(f"嘗試 {attempt} 失敗: {e}. {current_delay}秒后重試...")
                    time.sleep(current_delay)
                    current_delay *= backoff  # 指數(shù)退避
                else:
                    print(f"所有 {max_attempts} 次嘗試均失敗")
                    raise last_exception
        return wrapper

# 使用示例
@retry(max_attempts=5, delay=2.0, exceptions=(ConnectionError, TimeoutError))
def api_call(url):
    # 網(wǎng)絡(luò)請求邏輯
    pass

import time
from functools import wraps, partial

def monitor(func=None, *, threshold=1.0, enable_profile=False):
    """性能監(jiān)控裝飾器"""
    if func is None:
        return partial(monitor, threshold=threshold, enable_profile=enable_profile)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        start_process_time = time.process_time()
        
        result = func(*args, **kwargs)
        
        wall_time = time.perf_counter() - start_time
        cpu_time = time.process_time() - start_process_time
        
        if wall_time > threshold:
            print(f"性能警告: {func.__name__} 執(zhí)行時(shí)間 {wall_time:.3f}s 超過閾值")
        
        if enable_profile:
            print(f"{func.__name__} - 墻鐘時(shí)間: {wall_time:.6f}s, CPU時(shí)間: {cpu_time:.6f}s")
        
        return result
    return wrapper

# 根據(jù)環(huán)境配置不同的監(jiān)控級別
@monitor  # 生產(chǎn)環(huán)境：基本監(jiān)控
def production_function():
    pass

@monitor(threshold=0.5, enable_profile=True)  # 開發(fā)環(huán)境：詳細(xì)分析
def development_function():
    pass

@decorator1
@decorator2(param=value)
@decorator3
def example_function():
    pass

from functools import wraps

class ClassBasedDecorator:
    """基于類的可選參數(shù)裝飾器"""
    def __init__(self, func=None, *, param1=default1, param2=default2):
        self.func = func
        self.param1 = param1
        self.param2 = param2
        
        if func is not None:
            # 直接@decorator調(diào)用
            self.__call__ = wraps(func)(self.__call__)
    
    def __call__(self, *args, **kwargs):
        if self.func is None:
            # 被以@decorator(...)形式調(diào)用
            func = args[0] if args else kwargs.pop('func', None)
            return type(self)(func, param1=self.param1, param2=self.param2)
        
        # 實(shí)際包裝邏輯
        @wraps(self.func)
        def wrapper(*args, **kwargs):
            # 使用self.param1和self.param2
            return self.func(*args, **kwargs)
        return wrapper

# 使用方式與函數(shù)裝飾器相同
@ClassBasedDecorator(param1="value")
def example():
    pass

from functools import wraps, partial

def validated_decorator(func=None, *, max_timeout=300):
    """帶參數(shù)驗(yàn)證的裝飾器"""
    # 參數(shù)驗(yàn)證
    if not isinstance(max_timeout, (int, float)) or max_timeout <= 0:
        raise ValueError("超時(shí)時(shí)間必須是正數(shù)")
    
    if func is None:
        return partial(validated_decorator, max_timeout=max_timeout)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            # 裝飾邏輯
            return func(*args, **kwargs)
        except Exception as e:
            # 錯(cuò)誤處理和日志記錄
            print(f"裝飾器捕獲異常: {e}")
            raise
    return wrapper

def optimized_decorator(func=None, *, enable_feature=True):
    """性能優(yōu)化的裝飾器"""
    if func is None:
        return partial(optimized_decorator, enable_feature=enable_feature)
    
    if not enable_feature:
        # 功能禁用時(shí)直接返回原函數(shù)，零開銷
        return func
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 輕量級包裝邏輯
        return func(*args, **kwargs)
    return wrapper