Decorator 模式

from abc import ABC, abstractmethod
from typing import Protocol


class TextProcessor(Protocol):
    """文本处理器接口"""

    def process(self, text: str) -> str:
        ...


class SimpleTextProcessor:
    """简单文本处理器"""

    def process(self, text: str) -> str:
        return text


class TextDecorator:
    """装饰器基类"""

    def __init__(self, processor: TextProcessor):
        self.processor = processor

    def process(self, text: str) -> str:
        return self.processor.process(text)


class UpperCaseDecorator(TextDecorator):
    """转大写装饰器"""

    def process(self, text: str) -> str:
        return super().process(text).upper()


class LowerCaseDecorator(TextDecorator):
    """转小写装饰器"""

    def process(self, text: str) -> str:
        return super().process(text).lower()


class TrimDecorator(TextDecorator):
    """去除空白装饰器"""

    def process(self, text: str) -> str:
        return super().process(text).strip()


class ReverseDecorator(TextDecorator):
    """反转装饰器"""

    def process(self, text: str) -> str:
        return super().process(text)[::-1]


# 使用
def main():
    # 基础处理器
    processor: TextProcessor = SimpleTextProcessor()

    # 装饰：转大写
    processor = UpperCaseDecorator(processor)

    # 装饰：去除空白
    processor = TrimDecorator(processor)

    # 装饰：反转
    processor = ReverseDecorator(processor)

    # 处理文本
    result = processor.process("  Hello World  ")
    print(f"结果: {result}")  # "DLROW OLLEH"


if __name__ == "__main__":
    main()

from functools import wraps
import time


def timing_decorator(func):
    """计时装饰器"""

    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行时间: {end - start:.4f} 秒")
        return result

    return wrapper


def logging_decorator(func):
    """日志装饰器"""

    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}，参数: {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} 返回: {result}")
        return result

    return wrapper


def cache_decorator(func):
    """缓存装饰器"""
    cache = {}

    @wraps(func)
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]

    return wrapper


# 组合使用装饰器
@timing_decorator
@logging_decorator
@cache_decorator
def fibonacci(n: int) -> int:
    """计算斐波那契数列"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)


# 使用
def main():
    result = fibonacci(10)
    print(f"斐波那契数列第10项: {result}")


if __name__ == "__main__":
    main()

from typing import Callable, TypeVar, Any
from functools import wraps

T = TypeVar('T')


class PermissionChecker:
    """权限检查器"""

    def __init__(self, required_permission: str):
        self.required_permission = required_permission

    def check(self, user_permission: str) -> bool:
        return self.required_permission == user_permission


class PermissionDecorator:
    """权限装饰器"""

    def __init__(self, permission: str):
        self.permission = permission

    def __call__(self, func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 假设从 kwargs 中获取用户权限
            user_permission = kwargs.get('permission', 'guest')
            checker = PermissionChecker(self.permission)

            if checker.check(user_permission):
                return func(*args, **kwargs)
            else:
                raise PermissionError(f"需要 {self.permission} 权限")

        return wrapper


# 使用装饰器
@PermissionDecorator("admin")
def delete_user(user_id: int, **kwargs) -> str:
    return f"用户 {user_id} 已删除"


@PermissionDecorator("user")
def view_profile(user_id: int, **kwargs) -> str:
    return f"查看用户 {user_id} 的资料"


# 使用
def main():
    try:
        # 有权限
        result = view_profile(123, permission="user")
        print(result)

        # 无权限
        delete_user(456, permission="guest")
    except PermissionError as e:
        print(f"错误: {e}")


if __name__ == "__main__":
    main()