策略模式

from abc import ABC, abstractmethod

# Strategy抽象类
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount: float):
        pass

# ConcreteStrategyA类（信用卡支付）
class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number: str, card_holder: str, cvv: str, expiry_date: str):
        self.card_number = card_number
        self.card_holder = card_holder
        self.cvv = cvv
        self.expiry_date = expiry_date

    def pay(self, amount: float):
        print(f"通过信用卡支付: ${amount}")
        # 这里可以添加实际的支付逻辑，如调用支付网关API

# ConcreteStrategyB类（支付宝支付）
class AlipayPayment(PaymentStrategy):
    def __init__(self, email: str):
        self.email = email

    def pay(self, amount: float):
        print(f"通过支付宝支付: ${amount}")
        # 这里可以添加实际的支付逻辑，如调用支付宝API

# Context类
class ShoppingCart:
    def __init__(self):
        self.items = []
        self.payment_strategy = None

    def add_item(self, item):
        self.items.append(item)

    def remove_item(self, item):
        self.items.remove(item)

    def calculate_total(self) -> float:
        return sum(item.price for item in self.items)

    def set_payment_strategy(self, payment_strategy: PaymentStrategy):
        self.payment_strategy = payment_strategy

    def checkout(self):
        amount = self.calculate_total()
        if not self.payment_strategy:
            print("请选择支付方式。")
        else:
            self.payment_strategy.pay(amount)

# Item类
class Item:
    def __init__(self, name: str, price: float):
        self.name = name
        self.price = price

# 客户端代码
def strategy_pattern_demo():
    cart = ShoppingCart()

    item1 = Item("书籍", 30.00)
    item2 = Item("笔记本", 20.00)
    item3 = Item("钢笔", 50.00)

    cart.add_item(item1)
    cart.add_item(item2)
    cart.add_item(item3)

    # 使用信用卡支付
    credit_card = CreditCardPayment("1234567890123456", "张三", "123", "12/25")
    cart.set_payment_strategy(credit_card)
    cart.checkout()

    # 使用支付宝支付
    alipay = AlipayPayment("zhangsan@example.com")
    cart.set_payment_strategy(alipay)
    cart.checkout()

if __name__ == "__main__":
    strategy_pattern_demo()

from abc import ABC, abstractmethod

# Strategy抽象类
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: list) -> list:
        pass

# ConcreteStrategyA类（快速排序）
class QuickSort(SortStrategy):
    def sort(self, data: list) -> list:
        print("使用快速排序算法排序数据。")
        if len(data) <= 1:
            return data
        pivot = data[len(data) // 2]
        left = [x for x in data if x < pivot]
        middle = [x for x in data if x == pivot]
        right = [x for x in data if x > pivot]
        return QuickSort().sort(left) + middle + QuickSort().sort(right)

# ConcreteStrategyB类（归并排序）
class MergeSort(SortStrategy):
    def sort(self, data: list) -> list:
        print("使用归并排序算法排序数据。")
        if len(data) <= 1:
            return data
        mid = len(data) // 2
        left = MergeSort().sort(data[:mid])
        right = MergeSort().sort(data[mid:])
        return self.merge(left, right)

    def merge(self, left: list, right: list) -> list:
        result = []
        i = j = 0
        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result.extend(left[i:])
        result.extend(right[j:])
        return result

# Context类
class Sorter:
    def __init__(self, strategy: SortStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: SortStrategy):
        self._strategy = strategy

    def sort_data(self, data: list) -> list:
        return self._strategy.sort(data)

# 客户端代码
def strategy_pattern_sort_demo():
    data = [38, 27, 43, 3, 9, 82, 10]
    print("原始数据:", data)

    sorter = Sorter(QuickSort())
    sorted_data = sorter.sort_data(data.copy())
    print("快速排序结果:", sorted_data)

    sorter.set_strategy(MergeSort())
    sorted_data = sorter.sort_data(data.copy())
    print("归并排序结果:", sorted_data)

if __name__ == "__main__":
    strategy_pattern_sort_demo()

from abc import ABC, abstractmethod

# Strategy抽象类
class LogStrategy(ABC):
    @abstractmethod
    def log(self, message: str):
        pass

# ConcreteStrategyA类（控制台日志）
class ConsoleLogStrategy(LogStrategy):
    def log(self, message: str):
        print(f"控制台日志: {message}")

# ConcreteStrategyB类（文件日志）
class FileLogStrategy(LogStrategy):
    def __init__(self, file_path: str):
        self.file_path = file_path

    def log(self, message: str):
        with open(self.file_path, 'a') as file:
            file.write(f"{message}
")
        print(f"文件日志写入: {message}")

# ConcreteStrategyC类（远程服务器日志）
class RemoteServerLogStrategy(LogStrategy):
    def __init__(self, server_url: str):
        self.server_url = server_url

    def log(self, message: str):
        # 模拟远程日志发送
        print(f"远程服务器({self.server_url})接收到日志: {message}")
        # 这里可以添加实际的网络请求逻辑，如HTTP POST请求

# Context类
class Logger:
    def __init__(self, strategy: LogStrategy):
        self._strategy = strategy

    def set_strategy(self, strategy: LogStrategy):
        self._strategy = strategy

    def log_message(self, message: str):
        self._strategy.log(message)

# 客户端代码
def strategy_pattern_logging_demo():
    logger = Logger(ConsoleLogStrategy())
    logger.log_message("系统启动。")

    logger.set_strategy(FileLogStrategy("app.log"))
    logger.log_message("用户登录成功。")

    logger.set_strategy(RemoteServerLogStrategy("http://logserver.example.com"))
    logger.log_message("异常错误发生。")

if __name__ == "__main__":
    strategy_pattern_logging_demo()