5-5 设计模式：行为型模式Python应用面试题

一、行为型模式常考题

常见行为型设计模式
1.迭代器模式（Iterator）：通过统一的接口迭代对象
2.观察者模式（Observer）：对象发生改变的时候，观察者执行相应动作
3.策略模式（Strategy）：针对不同规模输入使用不同的策略

二、迭代器模式

迭代器模式（Iterator）
1.Python内置对迭代器模式的支持
2.比如我们可以用for遍历各种 Iterable的数据类型
3.Python里可以实现__next__和__iter__实现迭代器

from collections import deque

class Stack:		# 使用组合的例子
	def __init__(self):
		self._deque = deque()   # has a deque()

	def push(self, val):
		return self._deque.append(val)
	
	def pop(self):
		return self._deque.pop()
	
	def empty(self):
		return len(self._deque) == 0

	def __iter__(self):
		res = [i for i in self._deque]
		for i in reversed(res):
			yield i

s = Stack()
s.push(1)
s.push(2)
for i in s:
	print(i)	

运行结果：

三、观察者模式

1.发布订阅是一种最常用的实现方式
2.发布订阅用于解耦逻辑
3.可以通过回调等方式实现，当发生事件时，调用相应的回调函数

# 发布订阅模式
class Publisher:  # 发布者
    def __init__(self):
        self.observers = []  # 观察者

    def add(self, observer):  # 加入观察者
        if observer not in self.observers:
            self.observers.append(observer)
        else:
            print('Failed to add : {}').format(observer)

    def remove(self, observer):  # 移除观察者
        try:
            self.observers.remove(observer)
        except ValueError:
            print('Failed to remove : {}').format(observer)

    def notify(self):   # 调用观察者的回调
        [o.notify_by(self) for o in self.observers]


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("{}: '{}' has now bin data = {}".format(
            type(self).__name__,
            publisher.name,
            bin(publisher.data))
        )

def test():
    df = Formatter('formatter') # 发布者
    bf = BinaryFormatter()  # 订阅者
    df.add(bf)  # 添加订阅者
    df.data = 3  # 设置的时候调用订阅者的notify_by

四、策略模式

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

# 策略模式
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):
        fmt = ""
        return fmt.format(
            self.price, self.price_after_discount()
        )


def ten_percent_discount(order):
    return order.price * 0.10


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)
    print(order1)
    print(order2)