Python中的策略模式之解锁编程的新维度

from abc import ABC, abstractmethod
class Strategy(ABC):
    @abstractmethod
    def do_algorithm(self, data):
        pass
class ConcreteStrategyA(Strategy):
    def do_algorithm(self, data):
        return sorted(data)
class ConcreteStrategyB(Strategy):
    def do_algorithm(self, data):
        return reversed(sorted(data))
class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy
    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy
    def do_some_business_logic(self, data):
        result = self._strategy.do_algorithm(data)
        print(f"Sorting data with {type(self._strategy).__name__}: {result}")
if __name__ == "__main__":
    context = Context(ConcreteStrategyA())
    context.do_some_business_logic([1, 3, 2])
    context.set_strategy(ConcreteStrategyB())
    context.do_some_business_logic([1, 3, 2])

from abc import ABC, abstractmethod
class ProductSorter(ABC):
    @abstractmethod
    def sort_products(self, products):
        pass
class PriceSorter(ProductSorter):
    def sort_products(self, products):
        return sorted(products, key=lambda p: p.price)
class PopularitySorter(ProductSorter):
    def sort_products(self, products):
        return sorted(products, key=lambda p: p.popularity, reverse=True)
class Product:
    def __init__(self, name, price, popularity):
        self.name = name
        self.price = price
        self.popularity = popularity
products = [
    Product("Laptop", 1200, 5),
    Product("Headphones", 150, 3),
    Product("Smartphone", 800, 7)
]
context = Context(PriceSorter())
sorted_by_price = context.sort_products(products)
print("Sorted by price:", [p.name for p in sorted_by_price])
context.set_strategy(PopularitySorter())
sorted_by_popularity = context.sort_products(products)
print("Sorted by popularity:", [p.name for p in sorted_by_popularity])

class User:
    def __init__(self, id, purchase_history, membership_level):
        self.id = id
        self.purchase_history = purchase_history
        self.membership_level = membership_level
def get_recommendation_strategy(user: User):
    if user.membership_level == "premium":
        return PremiumUserRecommendationStrategy()
    else:
        return RegularUserRecommendationStrategy()
class RecommendationStrategy(ABC):
    @abstractmethod
    def recommend_products(self, user: User):
        pass
class RegularUserRecommendationStrategy(RecommendationStrategy):
    def recommend_products(self, user: User):
        # Implement logic for regular users
        pass
class PremiumUserRecommendationStrategy(RecommendationStrategy):
    def recommend_products(self, user: User):
        # Implement logic for premium users
        pass
# Example usage
user = User(1, ["laptop", "smartphone"], "premium")
strategy = get_recommendation_strategy(user)
recommended_products = strategy.recommend_products(user)
print("Recommended products:", recommended_products)

from abc import ABC, abstractmethod
class PricingStrategy(ABC):
    @abstractmethod
    def calculate_price(self, base_price):
        pass
class USDollarPricingStrategy(PricingStrategy):
    def calculate_price(self, base_price):
        return base_price * 1.15  # Assuming exchange rate of 1.15 USD/CNY
class CNYPricingStrategy(PricingStrategy):
    def calculate_price(self, base_price):
        return base_price
class Product:
    def __init__(self, name, base_price):
        self.name = name
        self.base_price = base_price
def get_pricing_strategy(user_location):
    if user_location == "US":
        return USDollarPricingStrategy()
    else:
        return CNYPricingStrategy()
# Example usage
product = Product("Smartphone", 800)
strategy = get_pricing_strategy("US")
final_price = strategy.calculate_price(product.base_price)
print(f"Final price for {product.name} in US: {final_price} USD")
strategy = get_pricing_strategy("CN")
final_price = strategy.calculate_price(product.base_price)
print(f"Final price for {product.name} in CN: {final_price} CNY")