《Fluent Python》学习笔记：第 6 章使用一等函数实现设计模式

最新推荐文章于 2023-02-12 19:54:53 发布

Jock2018

最新推荐文章于 2023-02-12 19:54:53 发布

阅读量263

点赞数

分类专栏： Python进阶(更新中...) 文章标签： Python

本文链接：https://blog.csdn.net/qq_27283619/article/details/106390937

版权

Python进阶(更新中...) 专栏收录该内容

12 篇文章 16 订阅

订阅专栏

本文主要是 Fluent Python 第 6 章的学习笔记。这部分主要是介绍了使用一等函数实现策略模式和命令模式等。

《Fluent Python》学习笔记：第 6 章使用一等函数实现设计模式

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

《设计模式：可复用面向对象软件的基础》对策略模式的总结如下：

定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。

电商领域中，根据客户的属性或订单中的商品计算折扣，就非常适合用策略模式。
假如有一个网店制定了下述折扣规则：

1000 或以上积分客户，每个订单享 5%折扣。
同一订单中，单个商品数量超过 20 个或以上，享受 10%折扣。
订单中的不同商品达到 10 个或以上，享 7%折扣。

简单起见，我们假定一个订单只能享受一个折扣。

分析：
上下文(Context）：把一些计算委托给实现不同算法的可互换组件，他提供服务。这个电商例子中，上下文是 Order，它会根据不同的算法计算促销折扣。
策略（Strategy）：实现不同算法的组件共同接口。在这个示例中，名为 promotion 的抽象类扮演这个角色。
具体策略（Concrete strategy）：“策略”的具体子类，FidelityPromo、BulkPromo 和 LargeOrderPromo 是这里实现的三个具体策略。

具体策略由上下文类的客户选择，这个例子中，实例化订单之前，系统会以某种方式选择一种促销折扣策略，然后把它传给 Order 构造方法。具体怎么选择策略，不在这模式的职责范围内。

# 实现 Order 类，支持插入式折扣策略
from abc import ABC, abstractmethod
from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')


class LineItem(object):

    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(object):  # 上下文

    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


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


joe = Customer('John Doe', 0)  # joe 积分为0
ann = Customer('Ann Smith', 1100)  # ann 积分是1100
cart = [
    LineItem('banana', 4, .5),  # 有三个商品的购物车
    LineItem('apple', 10, 1.5),
    LineItem('watermellon', 5, 5.0)
]
print(Order(joe, cart, FidelityPromo()))  # FidelityPromo 没给 joe 提供折扣
print(Order(ann, cart, FidelityPromo()) ) # ann 获得了5%折扣<，因为她的积分超过1000
banana_cart = [
    LineItem('banana', 30, .5),
    LineItem('apple', 10, 1.5)
]
print(Order(joe, banana_cart, BulkItemPromo()))  #  为 joe 优惠了1.5美元
long_order = [LineItem(str(item_code), 1, 1.0) for item_code in range(10)]  # long_order 有10个不同的商品，每个商品价格1美元
print(Order(joe, long_order, LargeOrderPromo()))  # 为joe的整个订单提供了7%折扣
print(Order(joe, cart, LargeOrderPromo()))

<Order total: 42.00 due: 42.00>
<Order total: 42.00 due: 39.90>
<Order total: 30.00 due: 28.50>
<Order total: 10.00 due: 9.30>
<Order total: 42.00 due: 42.00>

可以看到上述的例子完全可用，但是利用 Python 中作为对象的函数，可以使用更少的代码实现相同的功能。

使用函数实现“策略”模式。
上面的例子中，具体的策略都是一个单独的类，每个类里面只有一个方法，没有实例属性。因此我们可以把具体策略变成简单函数，去掉 Promo 抽象类。重构如下：

# 实现 Order 类，支持插入式折扣策略
from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')


class LineItem(object):

    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(object):  # 上下文

    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)  # 计算折扣只需调用self.promotion()函数
        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


joe = Customer('John Doe', 0)  # joe 积分为0
ann = Customer('Ann Smith', 1100)  # ann 积分是1100
cart = [
    LineItem('banana', 4, .5),  # 有三个商品的购物车
    LineItem('apple', 10, 1.5),
    LineItem('watermellon', 5, 5.0)
]
print(Order(joe, cart, fidelity_promo))  # FidelityPromo 没给 joe 提供折扣
print(Order(ann, cart, fidelity_promo) ) # ann 获得了5%折扣<，因为她的积分超过1000
banana_cart = [
    LineItem('banana', 30, .5),
    LineItem('apple', 10, 1.5)
]
print(Order(joe, banana_cart, bulk_item_promo))  #  为 joe 优惠了1.5美元
long_order = [LineItem(str(item_code), 1, 1.0) for item_code in range(10)]  # long_order 有10个不同的商品，每个商品价格1美元
print(Order(joe, long_order, large_order_promo))  # 为joe的整个订单提供了7%折扣
print(Order(joe, cart, large_order_promo))

<Order total: 42.00 due: 42.00>
<Order total: 42.00 due: 39.90>
<Order total: 30.00 due: 28.50>
<Order total: 10.00 due: 9.30>
<Order total: 42.00 due: 42.00>

策略对象通常是很好的享元（flyweight）。享元：只可以共享的对象，可以同时在多个上下文中使用。共享是推荐的做法。

进一步优化刚刚的这个电商例子。选择最佳策略：增加一个 best_promo 函数

# best_promo 迭代一个函数列表，并找到折扣最大的
promos = [fidelity_promo, bulk_item_promo, large_order_promo]  # 列出以函数实现的各个策略

def best_promo(order):
    """选择最佳折扣"""
    return max(promo(order) for promo in promos)

进一步优化，globals() 返回一个字典，表示当前的全局符号表。这样可以避免添加了新的促销策略后，还需要手动修改，promos。

# 构建 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)

6.2 “命令”模式

“命令”模式的目的是为了解耦调用操作的对象（调用者）和提供实现的对象（接收者）。
如调用者是图形应用程序中的菜单项，而接收者是被编辑的文档或应用程序自身。
这个模式的做法是，在二者之间放一个 Command 对象，让它实现只有一个方法（execute）的接口，调用接收者中的方法执行所需的操作。这样，调用者无需了解接收者的接口，而且不同的接收者可以适应不同的 Command 子类。

巨人的肩膀

《Fluent Python》
《流畅的 Python》

后记：
我从本硕药学零基础转行计算机，自学路上，走过很多弯路，也庆幸自己喜欢记笔记，把知识点进行总结，帮助自己成功实现转行。
2020下半年进入职场，深感自己的不足，所以2021年给自己定了个计划，每日学一技，日积月累，厚积薄发。
如果你想和我一起交流学习，欢迎大家关注我的微信公众号每日学一技，扫描下方二维码或者搜索每日学一技关注。
这个公众号主要是分享和记录自己每日的技术学习，不定期整理子类分享，主要涉及 C – > Python – > Java，计算机基础知识，机器学习，职场技能等，简单说就是一句话，成长的见证！

Jock2018

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《Fluent Python》学习笔记：第 6 章使用一等函数实现设计模式

本文主要是 Fluent Python 第 6 章的学习笔记。这部分主要是介绍了使用一等函数实现策略模式和命令模式等。《Fluent Python》学习笔记：第 6 章使用一等函数实现设计模式6.1 案例分析：重构“策略”模式6.2 “命令”模式巨人的肩膀6.1 案例分析：重构“策略”模式《设计模式：可复用面向对象软件的基础》对策略模式的总结如下：定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。电商领域中，根据客户的属性或订单中的商.
复制链接

扫一扫