设计模式：行为型模式python常用

• 常见学习行为型模式
  • 迭代器模式（Iterator):通过统一的接口迭代对象
  • 观察者模式（Observer):对象发生改变的时候，观察者执行相应动作
  • 策略模式（Strategy）：针对不同规模输入使用不同的策略
• 迭代器模式
  • python内置对迭代器模式的支持
  • for遍历各种Iterable的数据类型
  • python可以实现__next__和__iter__实现迭代器
  • 注意可迭代的和迭代器区别
  • eg:

    from collections import deque
    
    
    class Stack:
        def __init__(self):
            self._deque = deque()
    
        def push(self, value):
            return self._deque.append(value)
    
        def pop(self):
            return self._deque.pop()
    
        def empty(self):
            return len(self._deque) == 0
    
        def __iter__(self):
            res = []
            for i in self._deque:
                res.append(i)
            for i in reversed(res):
                yield i
    
    
    s = Stack()
    s.push(1)
    s.push(2)
    for i in s:
        print(i)
    

• 观察者模式
  • 发布订阅是一种最常用的实现方式
  • 发布订阅用于解耦逻辑
  • 可以通过回调等方式实现，当发生事件时，调用相应的回调函数
  • eg

    # 发布订阅模式
    
    # 发布者
    class Publisher:
        def __init__(self):
            self.observeers = []  # 观察者
    
        def add(self, observer):  # 加入观察者
            if observer not in self.observeers:
                self.observeers.append(observer)
            else:
                print(f"Failed to add:{observer}")
    
        def remove(self, observer):  # 移出观察者
            try:
                self.observeers.remove(observer)
            except ValueError:
                print(f"Failed to remove:{observer}")
    
        def notify(self):
            # 调用观察者的回调
            [o.notify_by(self) for o in self.observeers]
    
    
    class Formatter(Publisher):  # 继承自发布者
        def __init__(self, name):
            super().__init__()
            self.name = name
            self._data = 0
    
        @property
        def data(self):
            return self._data
    
        @data.setter
        def data(self, new_value):
            self._data = int(new_value)
            self.notify()  # data被合法赋值以后回执行notify
    
    
    # 订阅者
    class BinaryFormatter:
        def notify_by(self, publisher):
            print(f"{type(self).__name__}:{publisher.name} has now bin data = {bin(publisher.data)}")
    
    
    df = Formatter('formatter')  # 发布者
    bf = BinaryFormatter()  # 订阅者
    df.add(bf)  # 添加订阅者
    df.data = 3  # 设置的时候调用订阅者的notify_by
    

• 策略模式
  • 根据不同的输入采用不同的策略
  • 比如买东西超过10个打八折，超过20个打七折
  • 对外暴露统一的接口，内部采用不同的策略计算
  • eg

    
    # 策略模式
    class Order:
        def __init__(self, price, discount_strategy=None):
            self.price = price
            self.discount_strategy = discount_strategy
    
        def price_after_discount(self):
            if self.discount_strategy:
                discount = self.discount_strategy(self)
            else:
                discount = 0
            return self.price - discount
    
        def __repr__(self):
            return f"<Price: {self.price}, price after discount:{self.price_after_discount()}"
    
    
    def ten_percent_discount(order):
        return order.price * 0.1
    
    
    def on_sale_discount(order):
        return order.price * 0.25 + 20
    
    
    def main():
        order0 = Order(100)
        order1 = Order(100, discount_strategy=ten_percent_discount)
        order2 = Order(1000, discount_strategy=on_sale_discount)
        print(order0, order1, order2)