快捷導(dǎo)航

python中兩種策略模式的實(shí)現(xiàn)方法示例

更新時(shí)間：2025年07月04日 08:46:16 作者：熱愛(ài)生活的猴子

策略模式是一種行為型設(shè)計(jì)模式,它將一組可互換的算法封裝成獨(dú)立的類(lèi),使它們可以在運(yùn)行時(shí)靈活切換,這篇文章主要介紹了python中兩種策略模式的實(shí)現(xiàn)方法的相關(guān)資料,需要的朋友可以參考下

1. 基于接口/抽象類(lèi)的實(shí)現(xiàn)（含繼承）

這是經(jīng)典策略模式的定義方式，必然包含繼承關(guān)系：

from abc import ABC, abstractmethod

# 抽象策略類(lèi)（必須繼承）
class TextSplitterStrategy(ABC):
    @abstractmethod
    def split(self, text: str) -> list[str]:
        pass

# 具體策略類(lèi)（繼承抽象類(lèi)）
class RecursiveSplitter(TextSplitterStrategy):
    def split(self, text: str) -> list[str]:
        # 實(shí)現(xiàn)遞歸分割邏輯
        return chunks

class TokenSplitter(TextSplitterStrategy):
    def split(self, text: str) -> list[str]:
        # 實(shí)現(xiàn)按token分割邏輯
        return chunks

# 上下文類(lèi)（選擇策略）
class TextProcessor:
    def __init__(self, strategy: TextSplitterStrategy):
        self._strategy = strategy
    
    def process(self, text: str) -> list[str]:
        return self._strategy.split(text)

繼承關(guān)系：

TextSplitterStrategy (抽象基類(lèi))
├── RecursiveSplitter
├── TokenSplitter
└── OtherSplitters

實(shí)際使用方法：

方式1：運(yùn)行時(shí)動(dòng)態(tài)指定策略（顯式選擇）

適用場(chǎng)景：需要在代碼中根據(jù)不同條件靈活切換策略

操作方法：

在創(chuàng)建 TextProcessor 時(shí)，顯式傳入具體的策略實(shí)例
策略實(shí)例可通過(guò)條件判斷、配置參數(shù)或用戶(hù)輸入決定

# 根據(jù)不同條件選擇策略
if use_case == "code":
    strategy = TokenSplitter()  # 選擇Token分割策略
elif use_case == "document":
    strategy = RecursiveSplitter()  # 選擇遞歸分割策略
else:
    strategy = DefaultSplitter()

# 創(chuàng)建處理器并傳入策略
processor = TextProcessor(strategy=strategy)

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

方式2：通過(guò)工廠類(lèi)/函數(shù)封裝選擇邏輯（隱式選擇）

適用場(chǎng)景：希望隱藏策略選擇細(xì)節(jié)，簡(jiǎn)化調(diào)用方代碼

操作方法：

定義一個(gè)策略工廠函數(shù)或類(lèi)
根據(jù)輸入?yún)?shù)（如字符串標(biāo)識(shí)）返回對(duì)應(yīng)策略

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

# 使用工廠創(chuàng)建策略
strategy = get_splitter("token")  # 通過(guò)字符串標(biāo)識(shí)選擇
processor = TextProcessor(strategy=strategy)
result = processor.process("your_text_here")

2. 基于函數(shù)的實(shí)現(xiàn)（無(wú)繼承）

Python支持函數(shù)作為一等對(duì)象，策略模式可以完全不用繼承：

# 策略定義為普通函數(shù)
def recursive_split(text: str) -> list[str]:
    return chunks

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

# 上下文通過(guò)函數(shù)調(diào)用選擇策略
class TextProcessor:
    def __init__(self, split_strategy: callable):
        self._split = split_strategy
    
    def process(self, text: str) -> list[str]:
        return self._split(text)

無(wú)繼承關(guān)系，僅依賴(lài)函數(shù)簽名一致性（鴨子類(lèi)型）。

基礎(chǔ)使用方式

1. 直接傳遞策略函數(shù)

# 定義策略函數(shù)
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()  # 示例：按空格分詞

# 創(chuàng)建處理器時(shí)注入策略函數(shù)
processor = TextProcessor(split_strategy=recursive_split)  # 使用遞歸分割

# 處理文本
result = processor.process("這是一段需要分割的文本，長(zhǎng)度超過(guò)100個(gè)字符時(shí)應(yīng)自動(dòng)分割...")
print(result)

進(jìn)階使用方式

(1) 帶參數(shù)的策略函數(shù)

# 策略函數(shù)支持參數(shù)
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綁定參數(shù)
from functools import partial

# 創(chuàng)建固定參數(shù)的策略
custom_split = partial(dynamic_split, chunk_size=30)
processor = TextProcessor(split_strategy=custom_split)

(2) 策略工廠函數(shù)

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]

# 通過(guò)工廠獲取策略
strategy = get_strategy("dynamic", chunk_size=40)
processor = TextProcessor(strategy)