Python中的策略模式-电商大促销-原创手记-慕课网

前言

设计模式是我们实际应用开发中必不可缺的，对设计模式的理解有助于我们写出可读性和扩展更高的应用程序。虽然设计模式与语言无关，但并不意味着每一个模式都能在任何语言中使用，所以有必要去针对语言的特性去做了解。设计模式特别是对于java语言而言，已经有过非常多的大牛写过，所以这里我就不重复了。对于Python来说就相对要少很多，特别是python语言具有很多高级的特性，而不需要了解这些照样能满足开发中的很多需求，所以很多人往往忽视了这些，这里我们来在Pythonic中来感受一下设计模式。

1.介绍

策略模式也是常见的设计模式之一，它是指对一系列的算法定义，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。
这是比较官方的说法，看着明显的一股比较抽象的感觉，通俗来讲就是针对一个问题而定义出一个解决的模板，这个模板就是具体的策略，每个策略都是按照这个模板来的。这种情况下我们有新的策略时就可以直接按照模板来写，而不会影响之前已经定义好的策略。

2.具体实例

这里我用的《流畅的Python》中的实例，刚好双11过去不久，相信许多小伙伴也是掏空了腰包，哈哈。那这里就以电商领域的根据客户的属性或订单中的商品数量来计算折扣的方式来进行讲解，首先来看看下面这张图。
电商大促销
通过这张图，相信能对策略模式的流程有个比较清晰的了解了。然后看看具体的实现过程，首先我们用namedtuple来定义一个Customer，虽然这里是说设计模式，考虑到有些小伙伴可能对Python中的具名元组不太熟悉，所以这里也简单的说下。
namedtuple用来构建一个带字段名的元组和一个有名字的类，这样说可能还是有些抽象，这里来看看下面的代码

from collections import namedtuple
City = namedtuple('City','name country provinces')

这里测试就直接如下

changsha = City('Changsha','China','Hunan')
print(changsha)

结果如下

City(name='Changsha', country='China', province='Hunan')

还可以直接调用字段名

print(changsha.name)

更多用法可以去看看官方文档，这里重点还是讲设计模式。
好了，先来看看用类实现的策略模式

# 策略设计模式实例

from abc import ABC, abstractmethod
from collections import namedtuple

# 创建一个具名元组
Customer = namedtuple('Customer', 'name fidelity')

class LineItem:

    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price

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

# 上下文
class Order:
　　
　　＃ 传入三个参数，分别是消费者，购物清单，促销方式
    def __init__(self, customer, cart, promotion=None):
        self.customer = customer
        self.cart = list(cart)
        self.promotion = promotion

    def total(self):
        if not hasattr(self, '__total'):
            self.__total = sum(item.total() for item in self.cart)
        return self.__total

    def due(self):
        if self.promotion is None:
            discount = 0
        else:
            discount = self.promotion.discount(self)
        return self.total() - discount

    #　输出具体信息
    def __repr__(self):
        fmt = '<Order total: {:.2f} due: {:.2f}>'
        return fmt.format(self.total(), self.due())

# 策略　抽象基类
class Promotion(ABC):

    @abstractmethod
    def discount(self, order):
        """
        :param order:
        :return: 返回折扣金额（正值）
        """

# 第一个具体策略
class FidelityPromo(Promotion):
    """ 为积分为１０００或以上的顾客提供５％的折扣 """

    def discount(self, order):
        return order.total() * .05 if order.customer.fidelity >= 1000 else 0

# 第二个具体策略
class BulkItemPromo(Promotion):
    """ 单个商品为２０个或以上时提供１０％折扣"""

    def discount(self, order):
        discount = 0
        for item in order.cart:
            if item.quantity >= 20:
                discount = item.total() * .1
        return discount

# 第三个具体策略
class LargeOrderPromo(Promotion):
    """ 订单中的不同商品达到１０个或以上时提供％７的折扣"""

    def discount(self, order):
        distinct_items = {item.product for item in order.cart}
        if len(distinct_items) >= 10:
            return order.total() * .07
        return 0

这里是用类对象来实现的策略模式，每个具体策略类（折扣方式）都继承了Promotion这个基类，因为discount()是一个抽象函数，所以继承Promotion的子类都需要重写discount()函数（也就是进行具体的打折信息的函数）,这样一来，就很好的实现对象之间的解耦。这里的折扣方式有两类，一类是根据用户的积分，一类是根据用户所购买商品的数量。具体的折扣信息也都在代码块里面注释了，这里就不重复了，接下来我们来看看具体的测试用例

joe = Customer('John Doe', 0)
ann = Customer('Ann Smith', 1100)
cart = [LineItem('banana', 4, .5),
        LineItem('apple', 10, 1.5),
        LineItem('watermellon', 5, 5.0)]
print('John: ', Order(joe, cart, FidelityPromo()))
print('Ann: ', Order(ann, cart, FidelityPromo()))

这里定义了两消费者，John初始积分为０，Ann初始积分为1100，然后商品购买了４个香蕉，10个苹果，５个西瓜．．．说的都要流口水了，哈哈哈。回到正题,输出时采用第一种折扣方式，Run一下

John:  <Order total: 42.00 due: 42.00>
Ann:  <Order total: 42.00 due: 39.90>

3.优化措施

类变函数

上面的策略模式是使用的类对象实现的，其实我们还可以用函数对象的方法实现，看看具体的代码

# 策略设计模式实例

from collections import namedtuple

# 创建一个具名元组
Customer = namedtuple('Customer', 'name fidelity')

class LineItem:

    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price

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

# 上下文
class Order:

    def __init__(self, customer, cart, promotion=None):
        self.customer = customer
        self.cart = list(cart)
        self.promotion = promotion

    def total(self):
        if not hasattr(self, '__total'):
            self.__total = sum(item.total() for item in self.cart)
        return self.__total

    def due(self):
        if self.promotion is None:
            discount = 0
        else:
            discount = self.promotion.discount(self)
        return self.total() - discount

    def __repr__(self):
        fmt = '<Order total: {:.2f} due: {:.2f}>'
        return fmt.format(self.total(), self.due())

# 第一个具体策略
def fidelity_promo(order):
    """ 为积分为１０００或以上的顾客提供５％的折扣 """

    return order.total() * .05 if order.customer.fidelity >= 1000 else 0

# 第二个具体策略
def bulk_item_promo(order):
    """ 单个商品为２０个或以上时提供１０％折扣"""

    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount = item.total() * .1
    return discount

# 第三个具体策略
def large_order_promo(order):
    """ 订单中的不同商品达到１０个或以上时提供％７的折扣"""

    distinct_items = {item.product for item in order.cart}
    if len(distinct_items) >= 10:
        return order.total() * .07
    return 0

这种方式没有了抽象类，并且每个策略都是函数，实现同样的功能，代码量更加少，并且测试的时候可以直接把促销函数作为参数传入，这里就不多说了。

选择最佳策略

细心的朋友可能观察到，我们这样每次对商品进行打折处理时，都需要自己选择折扣方式，这样数量多了就会非常的麻烦，那么有没有办法让系统帮我们自动选择呢？当然是有的，这里我们可以定义一个数组,把折扣策略的函数当作元素传进去。

promos = [fidelity_promo,bulk_item_promo,large_order_promo]

然后定义一个函数

def best_promo(order):
    """  选择可用的最佳折扣　"""

    return max(promo(order) for promo in promos)

这样一来就省了很多时间，系统帮我们自动选择。但是仍然有一个问题，这个数组的元素需要我们手动输入，虽然工作量小，但是对于有强迫症的猿来说，依然是不行的，能用自动化的方式就不要用手动，所以继续做优化。

promos = [globals()[name] for name in globals()
              if name.endswith('_promo')
              and name != 'best_promo']

这里使用了globals()函数，我们就是使用这个函数来进行全局查找以'_promo'结尾的函数，并且过滤掉best_promo函数，又一次完成了我们的自动化优化。

最后，这篇blog就到这里了，相信你我都更加了解Python中的策略模式了，这里我推荐对Python感兴趣的朋友去看一下《Fluent Python》这本书，里面讲述了很多的高级特性,　更加让我们体验到Python中的美学。
首发legend's blog