python中两种策略模式的实现方法示例

from abc import ABC, abstractmethod

# 抽象策略类（必须继承）
class TextSplitterStrategy(ABC):
    @abstractmethod
    def split(self, text: str) -> list[str]:
        pass

# 具体策略类（继承抽象类）
class RecursiveSplitter(TextSplitterStrategy):
    def split(self, text: str) -> list[str]:
        # 实现递归分割逻辑
        return chunks

class TokenSplitter(TextSplitterStrategy):
    def split(self, text: str) -> list[str]:
        # 实现按token分割逻辑
        return chunks

# 上下文类（选择策略）
class TextProcessor:
    def __init__(self, strategy: TextSplitterStrategy):
        self._strategy = strategy
    
    def process(self, text: str) -> list[str]:
        return self._strategy.split(text)

# 根据不同条件选择策略
if use_case == "code":
    strategy = TokenSplitter()  # 选择Token分割策略
elif use_case == "document":
    strategy = RecursiveSplitter()  # 选择递归分割策略
else:
    strategy = DefaultSplitter()

# 创建处理器并传入策略
processor = TextProcessor(strategy=strategy)

# 使用处理器
result = processor.process("your_text_here")

def get_splitter(strategy_name: str) -> TextSplitterStrategy:
    """策略工厂函数"""
    strategies = {
        "recursive": RecursiveSplitter,
        "token": TokenSplitter,
        # 可扩展其他策略...
    }
    if strategy_name not in strategies:
        raise ValueError(f"Unknown strategy: {strategy_name}")
    return strategies[strategy_name]()

# 使用工厂创建策略
strategy = get_splitter("token")  # 通过字符串标识选择
processor = TextProcessor(strategy=strategy)
result = processor.process("your_text_here")

# 策略定义为普通函数
def recursive_split(text: str) -> list[str]:
    return chunks

def token_split(text: str) -> list[str]:
    return chunks

# 上下文通过函数调用选择策略
class TextProcessor:
    def __init__(self, split_strategy: callable):
        self._split = split_strategy
    
    def process(self, text: str) -> list[str]:
        return self._split(text)

# 定义策略函数
def recursive_split(text: str) -> list[str]:
    """递归分割策略"""
    return [text[i:i+100] for i in range(0, len(text), 100)]  # 示例：每100字符分割

def token_split(text: str) -> list[str]:
    """Token分割策略"""
    return text.split()  # 示例：按空格分词

# 创建处理器时注入策略函数
processor = TextProcessor(split_strategy=recursive_split)  # 使用递归分割

# 处理文本
result = processor.process("这是一段需要分割的文本，长度超过100个字符时应自动分割...")
print(result)

# 策略函数支持参数
def dynamic_split(text: str, chunk_size: int = 50) -> list[str]:
    return [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]

# 使用functools.partial绑定参数
from functools import partial

# 创建固定参数的策略
custom_split = partial(dynamic_split, chunk_size=30)
processor = TextProcessor(split_strategy=custom_split)

def get_strategy(strategy_name: str, **params) -> callable:
    """策略工厂"""
    strategies = {
        "recursive": recursive_split,
        "token": token_split,
        "dynamic": dynamic_split
    }
    
    if strategy_name == "dynamic":
        return partial(dynamic_split, **params)
    return strategies[strategy_name]

# 通过工厂获取策略
strategy = get_strategy("dynamic", chunk_size=40)
processor = TextProcessor(strategy)