Python 设计模式初探
本博客是在阅读精通Python设计模式(中文版)，以及阅读 Mask R-CNN 第三方Tensorflow代码的基础上记录得到。
豆瓣上似乎对该书的评价不高，这里仅以此书为基础，试图理解Python中常见的设计模式，并有效看懂相关代码
1. 工厂模式
1.1 实际需求
假设我希望对多种 CNN model （例如 "AlexNet" 和 "VGGNet"）的分类性能进行测试，因此我可能需要去实现不同的 CNN model的代码，并在主函数分别进行调用测试。
1.2 直接方式
我首先采用 Tensorflow(之后简写为TF) 编写多种类型的 CNN model 对应的 class。例如， "AlexNet" 对应的class是 AlexCNN，"VGGNet" 对应的class是 VGGCNN。然后在 main 函数中直接实例化不同类别的class，然后依次进行不同 网络 instance 的"训练" 和 "测试"，最后得到每种CNN model的分类性能。
下面给出这种方式的代码示例：
# 多个类别的网络class 定义
class AlexCNN:
def __init__(*args, **kwargs):
# do initialization
class VGGCNN:
def __init__(*args, **kwargs):
# do initialization
if __name__ == "__main__":
A = AlexCNN()
B = VGGCNN()
# training and testing, etc
注意，这里的方式是将各个网络 class 的实例化放到主函数中进行。这样操作会使得内部的class暴露给外部。
我们希望采用一种新的方式，直接提出需求（给出网络类别），然后某函数返回给我一个实例化好了的类，我也不需要在main函数中去显式调用类别实例化了。
1.3 工厂设计模式
在工厂设计模式中，客户（我）只希望按照自己的要求（CNN model 类别）获得相应的商品（对应类别的 instance），而不关心商品是如何生成的。该设计模式背后的思想是希望简化对象的创建。
下面给出工厂设计模式的代码示例:
# 多个类别的网络class 定义
class AlexCNN:
def __init__(*args, **kwargs):
# do initialization
class VGGCNN:
def __init__(*args, **kwargs):
# do initialization
def CNN_factory(name, *args, **kwargs):
if str(name) == "AlexNet":
return AlexCNN(args, kwargs)
if str(name) == "VGGNet":
return VGGCNN(args, kwargs)
if __name__ == "__main__":
A = CNN_factory("AlexNet")
B = CNN_factory("VGGNet")
# training and testing, etc
与直接在main函数中实例化的方式相比，通过基于函数的实现，更易于追踪创建了哪些对象。通过将创建对象的代码和使用对象的代码解耦，工厂设计模式能够降低应用维护的复杂度。
2. 装饰器模式
2.1 实际需求
一个简单的例子
假设现在有多个函数，有的函数是递归的，我希望对这些函数进行微修改，然后打印输出系统在执行函数时，进行的调用过程以及消耗的时间
以下面两个函数为例，
# 非递归的
import time
def snooze(seconds):
time.sleep(seconds)
# 递归的
def factorial(n):
return 1 if n < 2 else n * factorial(n-1)
2.2 直接方式
2.2.1 直接修改每个函数内部的实现
当函数很少的时候，可以直接对函数内部进行修改，使其达到打印输出的功能
如下这样改造，
import time
def snooze(seconds, needPrint=False)
start_time = time.time()
time.sleep(seconds)
end_time = time.time()
# 新添加的
if needPrint:
print("[%f s] snooze(%s) -> None".format(end_time - start_time, str(seconds)))
def factorial(n, needPrint=False):
start_time = time.time()
result = 1 if n < 2 else n * factorial(n-1)
end_time = time.time()
if needPrint:
print("[%f s] snooze(%s) -> %s".format(end_time - start_time, str(n), str(result)))
return result
这种方式存在的问题是，原本的函数内部结构被修改得七零八落，打印输出的功能与函数本身的计算功能耦合在了一起，如果要改变打印方式，势必需要重新修改函数内部的打印输出的实现方式。增加了后续的维护成本。
2.2.2 传入打印函数
既然在函数内部直接编写打印代码不太合适，那就将打印函数以参数的形式传入。当需要修改打印输出模式时，直接修改打印函数的形式即可。相当于将打印函数与计算函数解耦。
如下这样改造，
import time
def printFunc1(elapsedTime, funcName, inputParam, outputParam):
print("[%s] %s(%s) -> %s".format(elapsedTime, funcName, str(inputParam), str(outputParam)))
def printFunc2(*args, **kwargs):
pass
def snooze(seconds, printFunc):
start_time = time.time()
time.sleep(seconds)
end_time = time.time()
printFunc(elapsedTime="[%f] s".format(end_time - start_time), funcName="snooze", inputParam=str(seconds), outputParam=str(None))
def factorial(n, printFunc):
start_time = time.time()
result = 1 if n < 2 else n * factorial(n-1)
end_time = time.time()
printFunc(elapsedTime="[%f] s".format(end_time - start_time), funcName="factorial", inputParam=str(n), outputParam=str(result))
return result
这种方式相比上一种方法，耦合性得以降低，但如果现在我想调用不带计时作用的函数，可能又得重新修改这个函数了。那能不能想一种方法，技能获得计时效果，又可以保证原来的函数不受到破坏
2.3 装饰器设计模式
2.3.1 什么是装饰器设计模式
在已有函数的基础上，我们希望对一个对象添加额外的功能。那么有以下几种方法：
- 如果合理，直接将功能添加到对象所属的类（例如，添加一个新的方法）
- 使用组合
- 使用继承
而装饰器模式则提供了第四种方法，以支持动态地（runtime，运行时）扩展一个对象的功能。装饰器（decorator）模式能够以透明的方式（不会影响其它对象）动态地将功能添加到一个对象中。
2.3.2 Python中的装饰器
很多编程语言中都使用子类化（继承）来实现装饰器模式。而Python中内置了装饰器特性。一个Python装饰器就是对Python语法的一个特定改变，用于扩展一个类，方法或函数的行为，而无需使用继承。
例如，假如有个名为decorate的装饰器：
# 用decorate装饰器来对以下的函数进行装饰
@decorate
def target():
print( "running target()")
# 实际上，上述写法是一种语法糖，它等价于
def target():
print( "running target()" )
target = decorate(target)
可以看到，装饰器是可以调用的对象，其参数是另一个函数（即被装饰的函数）。装饰器可能会处理被装饰的函数，然后把它返回，或者将其替换成另一个函数或可调用对象。
2.3.3 如何解决上述问题
直接上代码，
import time
def clock(func):
def clocked(*args):
t0 = time.perf_counter()
result = func(*args)
elapsed = time.perf_counter() - t0
name = func.__name__
arg_str = ', '.join(repr(arg) for arg in args)
print('[%0.8fs] %s(%s) -> %r' % (elapsed, name, arg_str, result))
return result
return clocked
@clock
def snooze(seconds):
time.sleep(seconds)
@clock
def factorial(n):
return 1 if n < 2 else n * factorial(n-1)
# 测试一下
if __name__ == "__main__":
print('*' * 40, 'Calling snooze(.123)')
snooze(.123)
print('*' * 40, 'Calling factorial(6)')
print('6! =', factorial(6))
可以看到，装饰器clock以函数为输入，输出的也是函数，但是中间加了额外的代码逻辑
