Python中如何实现策略模式 设计模式在算法切换中的作用

from abc import ABC, abstractmethod

# 策略接口
class CompressionStrategy(ABC):
    @abstractmethod
    def compress(self, data):
        pass

# 具体策略：JPEG压缩
class JpegCompression(CompressionStrategy):
    def compress(self, data):
        return f"JPEG compressed data: {data}"

# 具体策略：PNG压缩
class PngCompression(CompressionStrategy):
    def compress(self, data):
        return f"PNG compressed data: {data}"

# 上下文类
class ImageProcessor:
    def __init__(self, strategy: CompressionStrategy):
        self.strategy = strategy

    def set_strategy(self, strategy: CompressionStrategy):
        self.strategy = strategy

    def process_image(self, image_data):
        return self.strategy.compress(image_data)

# 客户端代码
if __name__ == "__main__":
    image_data = "Raw image data"

    # 使用JPEG压缩
    jpeg_processor = ImageProcessor(JpegCompression())
    compressed_data_jpeg = jpeg_processor.process_image(image_data)
    print(compressed_data_jpeg)

    # 切换到PNG压缩
    png_processor = ImageProcessor(PngCompression()) # 直接使用新的策略
    compressed_data_png = png_processor.process_image(image_data)
    print(compressed_data_png)

    jpeg_processor.set_strategy(PngCompression()) # 动态切换策略
    compressed_data_jpeg_again = jpeg_processor.process_image(image_data)
    print(compressed_data_jpeg_again)

from abc import ABC, abstractmethod
import random

class ABTestStrategy(ABC):
    @abstractmethod
    def execute(self, user_id):
        pass

class ControlGroup(ABTestStrategy):
    def execute(self, user_id):
        return f"User {user_id}: Showing control group experience."

class VariationA(ABTestStrategy):
    def execute(self, user_id):
        return f"User {user_id}: Showing variation A experience."

class ABTestContext:
    def __init__(self, strategy: ABTestStrategy):
        self.strategy = strategy

    def run_test(self, user_id):
        return self.strategy.execute(user_id)

# 模拟用户分配
def get_user_group(user_id):
    # 假设随机分配用户到控制组或变体A
    if random.random() < 0.5:
        return ControlGroup()
    else:
        return VariationA()

if __name__ == "__main__":
    user_id = 123
    strategy = get_user_group(user_id)
    context = ABTestContext(strategy)
    result = context.run_test(user_id)
    print(result)

    user_id = 456
    strategy = get_user_group(user_id)
    context = ABTestContext(strategy)
    result = context.run_test(user_id)
    print(result)

class CompressionStrategyFactory:
    def create_strategy(self, algorithm):
        if algorithm == "jpeg":
            return JpegCompression()
        elif algorithm == "png":
            return PngCompression()
        else:
            raise ValueError("Invalid compression algorithm")

if __name__ == "__main__":
    factory = CompressionStrategyFactory()
    algorithm = "jpeg" # 假设用户选择了JPEG压缩
    strategy = factory.create_strategy(algorithm)
    processor = ImageProcessor(strategy)
    compressed_data = processor.process_image("some image data")
    print(compressed_data)

from abc import ABC, abstractmethod

class ValidationStrategy(ABC):
    @abstractmethod
    def validate(self, data):
        pass

class EmailValidation(ValidationStrategy):
    def validate(self, data):
        if "@" in data and "." in data:
            return True
        return False

class LengthValidation(ValidationStrategy):
    def __init__(self, min_length, max_length):
        self.min_length = min_length
        self.max_length = max_length

    def validate(self, data):
        if self.min_length <= len(data) <= self.max_length:
            return True
        return False

class DataValidator:
    def __init__(self, strategy: ValidationStrategy):
        self.strategy = strategy

    def set_strategy(self, strategy: ValidationStrategy):
        self.strategy = strategy

    def validate_data(self, data):
        return self.strategy.validate(data)

if __name__ == "__main__":
    email_validator = DataValidator(EmailValidation())
    print(f"Email validation: {'test@example.com'}: {email_validator.validate_data('test@example.com')}")
    print(f"Email validation: {'invalid-email'}: {email_validator.validate_data('invalid-email')}")

    length_validator = DataValidator(LengthValidation(5, 10))
    print(f"Length validation: {'test'}: {length_validator.validate_data('test')}")
    print(f"Length validation: {'testtest'}: {length_validator.validate_data('testtest')}")
    print(f"Length validation: {'testtesttest'}: {length_validator.validate_data('testtesttest')}")