使用一等函数实现设计模式

案例分析：重构“策略”模式

如果合理利用作为一等对象的函数，某些设计模式可以简化，“策略”模式就是其中一个很好的例子。

经典的“策略”模式

“策略”模式对类编排的UML类图

《设计模式：可复用面向对象软件的基础》一书是这样概述“策略”模式的：
定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。

商领域有个功能明显可以使用“策略”模式，即根据客户的属性或订单中的商品计算折扣。
假如一个网店制定了下述折扣规则。
• 有1000或以上积分的顾客，每个订单享5%折扣。
• 同一订单中，单个商品的数量达到20个或以上，享10%折扣。
• 订单中的不同商品达到10个或以上，享7%折扣。
简单起见，我们假定一个订单一次只能享用一个折扣。

“策略”模式的UML类图见上图，其中涉及下列内容。

上下文
把一些计算委托给实现不同算法的可互换组件，它提供服务。在这个电商示例中，上下文是Order，它会根据不同的算法计算促销折扣。

策略
实现不同算法的组件共同的接口。在这个示例中，名为Promotion的抽象类扮演这个角色。

具体策略
“策略”的具体子类。fidelityPromo、BulkPromo和LargeOrderPromo是这里实现的三个具体策略。

#示例1：实现Order类，支持插入式折扣策略
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):
        """返回折扣金额（正值）"""
class FidelityPromo(Promotion):  # 第一个具体策略
    """为积分为1000或以上的顾客提供5%折扣"""
    def discount(self, order):
        return order.total() * .05 if order.customer.fidelity >= 1000 else 0
class BulkItemPromo(Promotion):  # 第二个具体策略
    """单个商品为20个或以上时提供10%折扣"""
    def discount(self, order):
        discount = 0
        for item in order.cart:
            if item.quantity >= 20:
                discount += item.total() * .1
        return discount
class LargeOrderPromo(Promotion):  # 第三个具体策略
    """订单中的不同商品达到10个或以上时提供7%折扣"""
    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定义为抽象基类（Abstract Base Class，ABC），这么做是为了使用@abstractmethod装饰器，从而明确表明所用的模式。

#示例2：使用不同促销折扣的Order类示例

>>> 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)] 
>>> Order(joe, cart, FidelityPromo())  #➌ 
<Order total: 42.00 due: 42.00> 
>>> Order(ann, cart, FidelityPromo())  #➍ 
<Order total: 42.00 due: 39.90> 
>>> banana_cart = [LineItem('banana', 30, .5),  #➎ 
...                LineItem('apple', 10, 1.5)] 
>>> Order(joe, banana_cart, BulkItemPromo())  #➏ 
<Order total: 30.00 due: 28.50> 
>>> long_order = [LineItem(str(item_code), 1, 1.0)  #➐ 
...               for item_code in range(10)] 
>>> Order(joe, long_order, LargeOrderPromo())  #➑ 
<Order total: 10.00 due: 9.30> 
>>> Order(joe, cart, LargeOrderPromo()) 
<Order total: 42.00 due: 42.00>

➊ 两个顾客：joe的积分是0，ann的积分是1100。
➋ 有三个商品的购物车。
➌ fidelityPromo没给joe提供折扣。
➍ ann得到了5%折扣，因为她的积分超过1000。
➎ banana_cart中有30把香蕉和10个苹果。
➏ BulkItemPromo为joe购买的香蕉优惠了1.50美元。
➐ long_order中有10个不同的商品，每个商品的价格为1.00美元。
➑ LargerOrderPromo为joe的整个订单提供了7%折扣。

使用函数实现“策略”模式

在上述实例中每个具体策略都是一个类，而且都只定义了一个方法，即discount。此外，策略实例没有状态（没有实例属性）。

下面的示例是对上述示例的重构，把具体策略换成了简单的函数，而且去掉了Promo抽象类。

#示例3：order类和使用函数实现的折扣策略
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(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):  #➌
    """为积分为1000或以上的顾客提供5%折扣"""
    return order.total() * .05 if order.customer.fidelity >= 1000 else 0
def bulk_item_promo(order):
    """单个商品为20个或以上时提供10%折扣"""
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * .1
    return discount
def large_order_promo(order):
    """订单中的不同商品达到10个或以上时提供7%折扣"""
    distinct_items = {item.product for item in order.cart}
    if len(distinct_items) >= 10:
        return order.total() * .07
    return 0

➊ 计算折扣只需调用self.promotion()函数。
➋ 没有抽象类。
➌ 各个策略都是函数。

#示例4
>>> 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)] 
>>> Order(joe, cart, fidelity_promo)  #➋ 
<Order total: 42.00 due: 42.00> 
>>> Order(ann, cart, fidelity_promo) 
<Order total: 42.00 due: 39.90> 
>>> banana_cart = [LineItem('banana', 30, .5), 
...                LineItem('apple', 10, 1.5)] 
>>> Order(joe, banana_cart, bulk_item_promo)  #➌ 
<Order total: 30.00 due: 28.50> 
>>> long_order = [LineItem(str(item_code), 1, 1.0) 
...               for item_code in range(10)] 
>>> Order(joe, long_order, large_order_promo) 
<Order total: 10.00 due: 9.30> 
>>> Order(joe, cart, large_order_promo) 
<Order total: 42.00 due: 42.00>

➊ 与示例1一样的测试固件。
➋ 为了把折扣策略应用到Order实例上，只需把促销函数作为参数传入。
➌ 这个测试和下一个测试使用不同的促销函数。

注意上述示例的标注：没必要在新建订单时实例化新的促销对象，函数拿来即用。

选择最佳策略：简单的方式

#示例5：best_promo函数计算所有折扣，并返回额度最大的
>>> Order(joe, long_order, best_promo)  #➊ 
<Order total: 10.00 due: 9.30> 
>>> Order(joe, banana_cart, best_promo)  #➋ 
<Order total: 30.00 due: 28.50> 
>>> Order(ann, cart, best_promo)  #➌ 
<Order total: 42.00 due: 39.90>

➊ best_promo为顾客joe选择larger_order_promo。
➋ 订购大量香蕉时，joe使用bulk_item_promo提供的折扣。
➌ 在一个简单的购物车中，best_promo为忠实顾客ann提供fidelity_promo优惠的折扣。

#best_promo迭代一个函数列表，并找出折扣额度最大的
promos = [fidelity_promo, bulk_item_promo, large_order_promo]  ➊ 
 
def best_promo(order):  ➋ 
    """选择可用的最佳折扣 
    """ 
    return max(promo(order) for promo in promos)  ➌

➊ promos列出以函数实现的各个策略。
➋ 与其他几个*_promo函数一样，best_promo函数的参数是一个Order实例。
➌ 使用生成器表达式把order传给promos列表中的各个函数，返回折扣额度最大的那个函数。
上述示例简单明了，promos是函数列表。习惯函数是一等对象后，自然而然就会构建那种数据结构存储函数。

找出模块中的全部策略

在Python中，模块也是一等对象，而且标准库提供了几个处理模块的函数。Python文档是这样说明内置函数globals的。

globals()
返回一个字典，表示当前的全局符号表。这个符号表始终针对当前模块（对函数或方法来说，是指定义它们的模块，而不是调用它们的模块）。

使用globals函数帮助best_promo自动找到其他可用的*_promo函数

#示例6：内省模块的全局命名空间，构建promos列表
promos = [globals()[name] for name in globals()  #➊ 
            if name.endswith('_promo')  #➋ 
            and name != 'best_promo']   #➌ 
 
def best_promo(order): 
    """选择可用的最佳折扣 
    """ 
    return max(promo(order) for promo in promos)  #➍

➊ 迭代globals()返回字典中的各个name。
➋ 只选择以_promo结尾的名称。
➌ 过滤掉best_promo自身，防止无限递归。
➍ best_promo内部的代码没有变化。

收集所有可用促销的另一种方法是，在一个单独的模块中保存所有策略函数，把best_promo排除在外。

#示例7：内省单独的promotions模块，构建promos列表
promos = [func for name, func in 
                inspect.getmembers(promotions, inspect.isfunction)] 
 
def best_promo(order): 
    """选择可用的最佳折扣 
    """ 
    return max(promo(order) for promo in promos)

上述示例最大的变化是内省名为promotion的独立模块，构建策略函数列表。

inspect.getmembers函数用于获取对象（这里是promotions模块）的属性，第二个参数是可选的判断条件（一个布尔值函数）