Python设计模式中的策略模式详解

import abc
from collections import namedtuple
from abc import abstractmethod
Customer = namedtuple('Customer', 'name fidelity')  # name:顾客名字  fidelity:忠诚度，这里用积分体现
class LineItem:
    """单品信息"""
    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price
    def total(self):
        return self.quantity * self.price
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):
        return '<Order total:{:.2f} due:{:.2f}>'.fORMat(self.total(), self.due())  # {:.2f}表示输出小数点，保留2位小数
class Promotion(abc.ABC):
    """策略：抽象基类"""
    @abstractmethod
    def discount(self, order):
        """返回折扣金额"""
class FidelityPromo(Promotion):
    """具体策略：有1000积分以上的顾客，整个订单可以享受5%的折扣"""
    def discount(self, order):
        return order.total() * 0.05 if order.customer.fidelity >= 1000 else 0
class BulkItemPromo(Promotion):
    """具体策略：同一个订单中，单个商品的数量达到20个以上，单品享受10%折扣"""
    def discount(self, order):
        # return order.total() * 0.1 if any(item for item in order.cart if item.quantity >= 20) else 0 理解错误为整体折扣
        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):
        return order.total() * 0.07 if len({item.product for item in order.cart}) >= 10 else 0

# 两个顾客，一个积分0，一个积分1100
joe = Customer('Joe', 0)
ann = Customer('Ann', 1100)
# 有三个商品的购物车
cart = [LineItem('banana', 4, .5),
        LineItem('apple', 10, 1.5),
        LineItem('watermelon', 5, 5.0)]
# ann因为超过1000积分，获得了5%折扣
order_joe = Order(joe, cart, FidelityPromo())  #这里要FidelityPromo要加（）来创建实例
print(order_joe)
order_ann = Order(ann, cart, FidelityPromo())
print(order_ann)
# 香蕉30个，苹果10个。
banana_cart = [LineItem('banana', 30, .5),
               LineItem('apple', 10, 1.5)]
# joe因为香蕉有30个，根据BulkItemPromo 香蕉优惠了1.5元
order_joe = Order(joe, banana_cart, BulkItemPromo())
print(order_joe)

Customer = namedtuple('Customer', 'name fidelity')  # name:顾客名字  fidelity:忠诚度，这里用积分体现
class LineItem:
    """单品信息"""
    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price
    def total(self):
        return self.quantity * self.price
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):
        return '<Order total:{:.2f} due:{:.2f}>'.format(self.total(), self.due())  # {:.2f}表示输出小数点，保留2位小数
def FidelityPromo(order):
    """具体策略：有1000积分以上的顾客，整个订单可以享受5%的折扣"""
    return order.total() * 0.05 if order.customer.fidelity >= 1000 else 0
def BulkItemPromo(order):
    """具体策略：同一个订单中，单个商品的数量达到20个以上，单品享受10%折扣"""
    discount = 0
    for item in order.cart:
        if item.quantity >= 20:
            discount += item.total() * .1
    return discount
def LargeOrderPromo(order):
    """具体策略：订单中不同商品的数量达到10个以上，整个订单享受7%折扣"""
    return order.total() * 0.07 if len({item.product for item in order.cart}) >= 10 else 0
# 两个顾客，一个积分0，一个积分1100
joe = Customer('Joe', 0)
ann = Customer('Ann', 1100)
# 有三个商品的购物车
cart = [LineItem('banana', 4, .5),
        LineItem('apple', 10, 1.5),
        LineItem('watermelon', 5, 5.0)]
# ann因为超过1000积分，获得了5%折扣
order_joe = Order(joe, cart, FidelityPromo)
print(order_joe)
order_ann = Order(ann, cart, FidelityPromo)
print(order_ann)
# 香蕉30个，苹果10个。
banana_cart = [LineItem('banana', 30, .5),
               LineItem('apple', 10, 1.5)]
# joe因为香蕉有30个，根据BulkItemPromo 香蕉优惠了1.5元
order_joe = Order(joe, banana_cart, BulkItemPromo)
print(order_joe)

def best_promotion(order):
    promotions = [FidelityPromo, BulkItemPromo, LargeOrderPromo]
    return max([func(order) for func in promotions])

def best_promotion(order):
    promotions = [globals()[key] for key in list(globals().keys()) if key.endswith('Promo')]
    return max([func(order) for func in promotions])

import promotions  # 一个包含函数的模块
print(inspect.getmembers(promotions, inspect.isfunction))  # 获取一个模块中的所有函数

import promotions
promotions = [func for func_name, func in inspect.getmembers(promotions, inspect.isfunction)]
def best_promotion(order):
    return max([func(order) for func in promotions])

import abc
class Receiver:
    """命令的接收者，执行命令的地方"""
    def start(self):
        print('开始执行')
    def stop(self):
        print('停止执行')
class Command(abc.ABC):
    """命令抽象类"""
    @abc.abstractmethod
    def execute(self):
        """命令对象对外只提供execute方法"""
class StartCommand(Command):
    """开始执行的命令"""
    def __init__(self, receiver):
        self.receiver = receiver
    def execute(self):
        return self.receiver.start()
class StopCommand(Command):
    """停止执行的命令"""
    def __init__(self, receiver):
        self.receiver = receiver
    def execute(self):
        return self.receiver.stop()
class Client:
    """命令的调用者"""
    def __init__(self, command):
        self.command = command
    def __call__(self, *args, **kwargs):
        return self.command.execute()
start = StartCommand(Receiver())
client = Client(start)
client()
stop = StopCommand(Receiver())
client = Client(stop)
client()