11

Fluent Python 笔记 —— 使用一等函数实现设计模式

 3 years ago
source link: https://rollingstarky.github.io/2020/11/08/fluent-python-first-class-function-and-design-patterns/
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

Fluent Python 笔记 —— 使用一等函数实现设计模式

2020-11-08

| Python

|

|

7.3k

|

0:07

经典的策略模式

“策略模式”：定义一系列算法，把它们一一封装，并且使它们之间可以相互替换。本模式使得算法可以独立于使用它的对象而变化

电商领域有个明显的功能可以使用“策略”模式，即根据客户的属性或订单中的商品计算折扣。
假如有如下折扣规则：

  • 有 1000 或以上积分的顾客，每个订单享 5% 折扣
  • 同一订单中，单个商品数量达到 20 个或以上，享 10% 折扣
  • 订单中的不同商品达到 10 个或以上，享 7% 折扣

UML图

如上述 UML 图，上下文提供服务，会把一些计算委托给实现不同算法的可互换组件。本例中是订单 Order，会根据不同算法计算促销折扣；
策略指实现不同算法的组件共用的接口。本例中是名为 Promotion 的抽象类；
具体策略即“策略”的具体子类，FidelityPromo、BulkPromo 和 LargeOrderPromo 是这里实现的三个具体策略。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
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

执行效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from order import *
>>> 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>

使用函数实现策略模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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):
    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):
    distince_items = {item.product for item in order.cart}
    if len(distince_items) >= 10:
        return order.total() * .07
    return 0

计算折扣只需调用 self.promotion() 函数，无需涉及到抽象类。各个策略都是由函数实现的。
为了把折扣策略应用到 Order 实例上，只需把促销函数作为参数传入。

执行效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> from order_fun import *
>>> 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>

具体策略一般没有内部状态，只是处理上下文中的数据。因此一定要使用普通的函数，而无需编写只有一个方法的类，再去实现另一个类声明的单函数接口。函数比用户自定义类的实例更为轻量，各个策略函数在 Python 编译模块时只会创建一次。即普通的函数是可共享的对象，可以同时在多个上下文中使用。

选择最佳策略

在上述代码的基础上，添加 best_promo 函数计算所有折扣，并返回额度最大的。

1
2
3
4
promos = [fidelity_promo, bulk_item_promo, large_order_promo]

def best_promo(order):
    return max(promo(order) for promo in promos)

与其他几个 *_promo 函数一样，best_promo 函数的参数是一个 Order 实例。使用生成器表达式把 order 传给 promos 列表中的各个函数，返回折扣额度最大的促销策略。
虽然上述代码可用且易于阅读，但若想添加新的促销策略，除了定义新的折扣函数以外，还应注意记得把新定义的函数添加到 promos 列表中。

可以使用内置的 globals() 函数找出模块中的全部策略。globals() 函数会返回一个字典，包含针对当前模块的全局符号表（对函数或方法来说，“当前模块”指的是定义它们的模块，而不是调用它们的模块）。

1
2
3
4
5
6
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)

动态收集促销折扣函数更为显式的一种方案是使用简单的装饰器。参考下一章节。

使用装饰器改进策略模式

使用注册装饰器可以改进前面的电商促销折扣示例。
之前的主要问题是，定义体中有函数名称，但 best_promo 用来判断哪个折扣幅度最大的 promos 列表中也有函数名称。这种重复导致新增折扣函数后可能会忘记把它添加到 promos 列表中，导致 best_promos 忽略新策略且不报错，为系统引入了不易察觉的缺陷。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
promos = []

def promotion(promo_func):
    promos.append(promo_func)
    return promo_func

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

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

@promotion
def large_order(order):
    discount_items = {item.product for item in order.cart}
    if len(discount_items) >= 10:
        return order.total() * .07
    return 0

def best_promo(order):
    return max(promo(order) for promo in promos)

promos 列表起初是空的，promotion 把 promo_func 添加到 promos 列表中，然后原封不动地将其返回。即被 @promotion 装饰的函数都会提前添加到 promos 列表中（装饰器在被装饰的函数定义之后（通常是在导入时）立即运行）。

相比于之前的方案，此方案有以下几个优点：

  • 促销函数无需使用特殊的名称（即不用以 _promo 结尾）
  • @promotion 装饰器突出了被装饰的函数的作用，还便于临时禁用某个促销策略：只需把装饰器注释掉
  • 促销折扣策略可以在其他模块中定义，只要使用 @promotion 装饰即可

Fluent Python


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK