流程的Python 第六章：使用一等函数来设计模式

前言：
Python函数的一等本性，这意味着，我们可以把函数赋值给变量、传给其他函数、存储在数据结构中，以及访问函数的属性，供框架和一些工具使用。

目录：

1. 内容回顾
2. 相关资料
3. 阅读后感

正文：
一. 内容回顾
1.1 案例分析： 重构“策略”模式
策略模式分析：

使用类：

# -*- coding:utf-8 -*-


class Strategy:
    def doStrategy(self, num1, num2):
        pass


class AddStrategy(Strategy):
    def doStrategy(self, num1, num2):
        print num1 + num2


class SubtractStrategy(Strategy):
    def doStrategy(self, num1, num2):
        print num1 - num2


class DoStrategy():
    def __init__(self, strategy):
        self.strategy = strategy

    def doStrategy(self, num1, num2):
        self.strategy.doStrategy(num1, num2)

if __name__ == '__main__':

    add = AddStrategy()
    subtract = SubtractStrategy()

    do = DoStrategy(add)
    do.doStrategy(10, 5)

    do = DoStrategy(subtract)
    do.doStrategy(10, 5)

使用函数：

# -*- coding:utf-8 -*-


def add(num1, num2):
    print num1 + num2


def subtract(num1, num2):
    print num1 - num2


class doStrategy:
    def __init__(self, function):
        self.function = function

    def do(self, num1, num2):
        self.function(num1, num2)

if __name__ == '__main__':
    ADD = add
    SUBTRACT = subtract

    addStrategy = doStrategy(ADD)
    addStrategy.do(10, 5)

    subtractStrategy = doStrategy(SUBTRACT)
    subtractStrategy.do(10, 5)

1.2 “命令”模式
命令模式分析：

使用类：

# -*- coding:utf-8 -*-


class Order:
    def execute(self):
        pass


class BugStock(Order):
    def __init__(self, stock):
        self.stock = stock

    def execute(self):
        self.stock.buy()


class SellStock(Order):
    def __init__(self, stock):
        self.stock = stock

    def execute(self):
        self.stock.sale()


class Stock:
    def buy(self):
        print "buy stock"

    def sale(self):
        print "sale stock"


class Broker:
    orderList = []

    def takeOrder(self, order):
        self.orderList.append(order)

    def placeOrder(self):
        for item in self.orderList:
            item.execute()


if __name__ == '__main__':
    stock = Stock()
    buy_stock = BugStock(stock)
    sell_stock = SellStock(stock)

    broker = Broker()
    broker.takeOrder(buy_stock)
    broker.takeOrder(sell_stock)
    broker.placeOrder()

使用函数：

# -*- coding:utf-8 -*-


def buyStock():
    print "buy stock"


def saleStock():
    print "Sale stock"


class Broker:
    orderList = []

    def takeOrder(self, order):
        self.orderList.append(order)

    def placeOrder(self):
        for item in self.orderList:
            item()


if __name__ == '__main__':
    BUYSTOCK = buyStock
    SALESTOCK = saleStock

    broker = Broker()
    broker.takeOrder(BUYSTOCK)
    broker.takeOrder(SALESTOCK)
    broker.placeOrder()

二. 相关资料
2.1 Python 策略模式
意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
主要解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。
何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。
如何解决：将这些算法封装成一个一个的类，任意地替换。
关键代码：实现同一个接口。
应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。
优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。
缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。
使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

2.2 Python 命令模式
意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。
主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。
何时使用：在某些场合，比如要对行为进行”记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将”行为请求者”与”行为实现者”解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。
如何解决：通过调用者调用接受者执行命令，顺序：调用者→接受者→命令。
关键代码：定义三个角色：1、received 真正的命令执行对象 2、Command 3、invoker 使用命令对象的入口
应用实例：struts 1 中的 action 核心控制器 ActionServlet 只有一个，相当于 Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的 Command。
优点： 1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。
缺点：使用命令模式可能会导致某些系统有过多的具体命令类。
使用场景：认为是命令的地方都可以使用命令模式，比如： 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD。
注意事项：系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作，也可以考虑使用命令模式，见命令模式的扩展。

三. 阅读后感
本章节主要是对前面一个章节提到的把函数视为对象进一步的补充，文章中提到的策略模式和命令模式，各有优点，在以后的编程中多多使用。

参考：
1. 设计模式-策略模式
2. 设计模式-命令模式