【设计模式】策略模式

前言

1. 单例模式(Singleton Pattern):保证一个类只有一个实例,并提供一个全局的访问点。

2. 工厂模式(Factory Pattern):定义一个创建对象的接口,但由子类决定要实例化的类是哪一个。

3. 观察者模式(Observer Pattern):定义对象之间的一对多依赖关系,使得当一个对象的状态发生改变时,所有依赖于它的对象都会被自动通知并更新。

4. 装饰器模式(Decorator Pattern):动态地给一个对象添加一些额外的职责,而不会影响到其他对象。

5. 策略模式(Strategy Pattern):定义一系列的算法,将每个算法封装起来,并使它们可以相互替换。

6. 命令模式(Command Pattern):将请求封装成一个对象,从而使用户可以用不同的请求对客户进行参数化。

7. 适配器模式(Adapter Pattern):将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的类能够一起工作。

8. 外观模式(Facade Pattern):为子系统中的一组接口提供一个统一的接口,从而使得子系统更加容易使用。

9. 状态模式(State Pattern):允许一个对象在其内部状态改变时改变其行为。

10. 模板方法模式(Template Method Pattern):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中实现。

这些是Python中常用的设计模式,通过使用这些设计模式可以提高代码的可读性、可维护性和重用性。


策略模式是一种行为设计模式,它定义了一系列算法,并将每个算法封装起来,使它们可以相互替换。策略模式允许客户端代码选择算法的实现方式,而不必改变其使用的上下文。

  • Context:上下文类,持有具体策略类的实例,并负责调用相关的算法
  • Strategy:策略抽象类,用来约束一系列的策略算法(Context 使用这个接口来调用具体的策略实现算法)
  • ConcreateStrategy:具体的策略类(继承抽象策略类)

策略模式

在Python中,可以通过定义一个为算法定义接口的Strategy基类,然后为从 Strategy类派生并实现该算法的每个算法定义一个单独的类来实现策略模式

代码示例 

# 策略接口
class PaymentStrategy:
    def pay(self, amount):
        pass

# 具体策略类1
class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid {amount} via credit card")

# 具体策略类2
class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid {amount} via PayPal")

# 上下文
class ShoppingCart:
    def __init__(self, payment_strategy):
        self._payment_strategy = payment_strategy

    def checkout(self, amount):
        self._payment_strategy.pay(amount)

# 使用策略模式
credit_card_payment = CreditCardPayment()
paypal_payment = PayPalPayment()

cart1 = ShoppingCart(credit_card_payment)
cart1.checkout(100)

cart2 = ShoppingCart(paypal_payment)
cart2.checkout(50)

在上面的例子中,PaymentStrategy 是策略接口,而 CreditCardPayment PayPalPayment 是具体的策略类。ShoppingCart 是上下文类,它包含了一个策略对象,并在 checkout 方法中调用策略的 pay 方法。

通过使用策略模式,可以轻松地添加新的支付策略,而不必修改 ShoppingCart 类的代码。这样的设计使得系统更加灵活,易于扩展和维护。

具体案例

Context

上下文类,持有具体策略类的实例,并负责调用相关的算法

class Customer:
    """顾客类"""

    def __init__(self, name, integral, is_vip):
        self.name = name
        self.integral = integral
        self.is_vip = is_vip

    def __repr__(self):
        return self.name


class Goods:
    """商品类"""

    def __init__(self, name, price, num):
        self.name = name
        self.price = price
        self.num = num

    def total(self):
        return self.price * self.num


class Order:
    """
    订单类
    关联上用户、对应的商品、折扣策略
    通过折扣策略来计算订单的实际价格
    """

    def __init__(self, customer, promotion=None):
        """
        :param customer: 顾客对象
        :param promotion: 折扣策略对象
        """
        self.cart = []  # 购物车
        self.customer = customer  # 客户信息
        self.promotion = promotion  # 具体的折扣策略

    def add_cart(self, *good):
        """商品加入购物车"""
        self.cart += good

    def total(self):
        """计算购物车商品总价"""
        return sum(map(lambda x: x.total(), self.cart))

    def due(self):
        """计算商品具体折扣后价格"""
        if self.promotion is None:
            return self.total()
        return self.total() - self.promotion.discount(self)

    def __repr__(self):
        return f"<{self.customer} Order total:{self.total()} due:{self.due()}>"

Strategy

策略抽象类,用来约束一系列的策略算法。

class Promotion(ABC):
    """折扣策略基类"""

    def discount(self, order):
        """计算折扣后的价格"""
        raise NotImplementedError

 未来我们具体实现的折扣策略必须是继承自Promotion的子类,并实现discount方法。

ConcreateStrategy

具体的折扣策略

class NoPromotion(Promotion):
    """不打折"""

    def discount(self, order):
        return 0  

class RatePromotion(Promotion):
    """按比例打折"""

    def __init__(self, rate):
        self.rate = rate

    def discount(self, order):
        return order.total() * (1 - self.rate)

可以观察到,我们使用Promotion作为子类的约束,而RatePromotion是具体的折扣策略。

通过Order类来协同消费者、商品、折扣策略,实现订单的折扣计算。

# 创建三个商品
good1 = Goods('apple', 10, 1)
good2 = Goods('banana', 20, 2)
good3 = Goods('orange', 30, 3)

# 创建一个消费者
customer = Customer('米乐', 100, False)

# 将消费者和折扣绑定到订单上
order = Order(
  customer=customer, 
  promotion=RatePromotion(0.8)
)
# 将商品添加到订单中
order.add_cart(good1, good2, good3)

print(order)
# <米乐 Order total:140 due:112.0>

 新的折扣策略来了,满100减10的活动。

class FullReductionPromotion(Promotion):
    """满减"""

    def __init__(self, full, reduction):
        self.full = full
        self.reduction = reduction

    def discount(self, order):
        return order.total() // self.full * self.reduction

 调用方式

order = Order(
        customer=customer,
        promotion=FullReductionPromotion(100, 10)
)
print(order)
# <米乐 Order total:140 due:130>

应用场景

  • APP的分享,它可以是微信分享,QQ分享,微博分享,各种分享所要输出的内容不一样,所以可以使用策略模式来实现不同的分享。
  • 再比如出门旅游,可以自驾、坐高铁、坐飞机,这种属于出行策略。
  • 日常网购各种折扣,礼金,满减等等折扣场景。

参考链接:

https://www.cnblogs.com/code05/p/17218156.html

你可能感兴趣的:(python,设计模式,策略模式)