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

重新登录一切归零

引言

策略模式是一种行为型设计模式，允许算法独立于使用它的客户端而变化。这使得我们可以根据不同的情况选择不同的算法或策略来解决问题，从而增强系统的灵活性。在日常开发中，策略模式常用于处理多种算法或行为之间的切换，比如在电子商务系统中实现多种支付方式，在游戏开发中实现角色的不同攻击模式等。

基础语法介绍


核心概念

• 策略接口（Strategy Interface）：定义了一组算法应该具有的公共接口。
  
• 具体策略类（Concrete Strategy Classes）：实现了策略接口，每个类代表一种具体的算法或策略。
  
• 上下文（Context）：使用策略接口，并且可以在运行时动态地改变所使用的具体策略类。
  

基本语法规则

在Python中，实现策略模式通常涉及定义一个抽象基类（或接口），然后创建多个继承自该基类的具体类来表示不同的策略。上下文对象负责调用策略对象的方法。

1. from abc import ABC, abstractmethod
   
2. class Strategy(ABC):
   
3.     @abstractmethod
   
4.     def do_algorithm(self, data):
   
5.         pass
   
6. class ConcreteStrategyA(Strategy):
   
7.     def do_algorithm(self, data):
   
8.         return sorted(data)
   
9. class ConcreteStrategyB(Strategy):
   
10.     def do_algorithm(self, data):
    
11.         return reversed(sorted(data))
    
12. class Context:
    
13.     def __init__(self, strategy: Strategy):
    
14.         self._strategy = strategy
    
15.     def set_strategy(self, strategy: Strategy):
    
16.         self._strategy = strategy
    
17.     def do_some_business_logic(self, data):
    
18.         result = self._strategy.do_algorithm(data)
    
19.         print(f"Sorting data with {type(self._strategy).__name__}: {result}")
    
20. if __name__ == "__main__":
    
21.     context = Context(ConcreteStrategyA())
    
22.     context.do_some_business_logic([1, 3, 2])
    
23.     context.set_strategy(ConcreteStrategyB())
    
24.     context.do_some_business_logic([1, 3, 2])

复制代码

基础实例

假设我们需要为一个在线商店提供多种排序商品的方式（按价格、销量等）。这里我们可以使用策略模式来实现这一需求。



问题描述

用户希望能够在浏览商品列表时，根据自己的偏好选择不同的排序方式。

代码示例

1. from abc import ABC, abstractmethod
   
2. class ProductSorter(ABC):
   
3.     @abstractmethod
   
4.     def sort_products(self, products):
   
5.         pass
   
6. class PriceSorter(ProductSorter):
   
7.     def sort_products(self, products):
   
8.         return sorted(products, key=lambda p: p.price)
   
9. class PopularitySorter(ProductSorter):
   
10.     def sort_products(self, products):
    
11.         return sorted(products, key=lambda p: p.popularity, reverse=True)
    
12. class Product:
    
13.     def __init__(self, name, price, popularity):
    
14.         self.name = name
    
15.         self.price = price
    
16.         self.popularity = popularity
    
17. products = [
    
18.     Product("Laptop", 1200, 5),
    
19.     Product("Headphones", 150, 3),
    
20.     Product("Smartphone", 800, 7)
    
21. ]
    
22. context = Context(PriceSorter())
    
23. sorted_by_price = context.sort_products(products)
    
24. print("Sorted by price:", [p.name for p in sorted_by_price])
    
25. context.set_strategy(PopularitySorter())
    
26. sorted_by_popularity = context.sort_products(products)
    
27. print("Sorted by popularity:", [p.name for p in sorted_by_popularity])

复制代码

进阶实例

在复杂环境下，我们可能需要考虑更多的因素，例如根据不同条件选择不同的策略组合。接下来，我们将通过一个更复杂的例子来进一步探讨策略模式的应用。
问题描述

某电商平台需要根据用户的购物历史、会员等级等因素动态调整推荐算法。

高级代码实例

1. class User:
   
2.     def __init__(self, id, purchase_history, membership_level):
   
3.         self.id = id
   
4.         self.purchase_history = purchase_history
   
5.         self.membership_level = membership_level
   
6. def get_recommendation_strategy(user: User):
   
7.     if user.membership_level == "premium":
   
8.         return PremiumUserRecommendationStrategy()
   
9.     else:
   
10.         return RegularUserRecommendationStrategy()
    
11. class RecommendationStrategy(ABC):
    
12.     @abstractmethod
    
13.     def recommend_products(self, user: User):
    
14.         pass
    
15. class RegularUserRecommendationStrategy(RecommendationStrategy):
    
16.     def recommend_products(self, user: User):
    
17.         # Implement logic for regular users
    
18.         pass
    
19. class PremiumUserRecommendationStrategy(RecommendationStrategy):
    
20.     def recommend_products(self, user: User):
    
21.         # Implement logic for premium users
    
22.         pass
    
23. # Example usage
    
24. user = User(1, ["laptop", "smartphone"], "premium")
    
25. strategy = get_recommendation_strategy(user)
    
26. recommended_products = strategy.recommend_products(user)
    
27. print("Recommended products:", recommended_products)

复制代码

实战案例

问题描述

在一个真实的电商项目中，我们需要根据用户的地理位置信息，动态调整商品的价格显示策略。例如，对于海外用户，显示美元价格；而对于国内用户，则显示人民币价格。

解决方案

引入策略模式，根据用户的地理位置信息动态选择合适的定价策略。

代码实现

1. from abc import ABC, abstractmethod
   
2. class PricingStrategy(ABC):
   
3.     @abstractmethod
   
4.     def calculate_price(self, base_price):
   
5.         pass
   
6. class USDollarPricingStrategy(PricingStrategy):
   
7.     def calculate_price(self, base_price):
   
8.         return base_price * 1.15  # Assuming exchange rate of 1.15 USD/CNY
   
9. class CNYPricingStrategy(PricingStrategy):
   
10.     def calculate_price(self, base_price):
    
11.         return base_price
    
12. class Product:
    
13.     def __init__(self, name, base_price):
    
14.         self.name = name
    
15.         self.base_price = base_price
    
16. def get_pricing_strategy(user_location):
    
17.     if user_location == "US":
    
18.         return USDollarPricingStrategy()
    
19.     else:
    
20.         return CNYPricingStrategy()
    
21. # Example usage
    
22. product = Product("Smartphone", 800)
    
23. strategy = get_pricing_strategy("US")
    
24. final_price = strategy.calculate_price(product.base_price)
    
25. print(f"Final price for {product.name} in US: {final_price} USD")
    
26. strategy = get_pricing_strategy("CN")
    
27. final_price = strategy.calculate_price(product.base_price)
    
28. print(f"Final price for {product.name} in CN: {final_price} CNY")

复制代码

扩展讨论

除了上述应用场景之外，策略模式还可以应用于许多其他领域，如日志记录、错误处理等。在实际工作中，我们可以根据项目的具体需求灵活运用策略模式，以达到最佳的效果。此外，结合其他设计模式（如工厂模式、装饰者模式等），可以进一步提升代码的灵活性和可维护性。
到此这篇关于Python中的策略模式：解锁编程的新维度的文章就介绍到这了,更多相关Python策略模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/python/328720l8d.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！