Python 设计模式初探

最新推荐文章于 2022-06-26 18:19:32 发布

LeadAI学院

最新推荐文章于 2022-06-26 18:19:32 发布

阅读量397

点赞数

北京站 | NVIDIA DLI深度学习培训

2018年1月26日

NVIDIA 深度学习学院带你快速进入火热的DL领域

阅读全文

正文共4097个字，4张图，预计阅读时间11分钟。

本文章是在阅读精通Python设计模式(中文版)（https://book.douban.com/subject/26829015/），以及阅读 Mask R-CNN 第三方Tensorflow代码的基础上记录得到。

豆瓣上似乎对该书的评价不高，这里仅以此书为基础，试图理解Python中常见的设计模式，并有效看懂相关代码。

工厂模式

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 initializationclass VGGCNN: def __init__(*args, **kwargs): # do initializationif __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 initializationclass VGGCNN: def __init__(*args, **kwargs): # do initializationdef 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.1 实际需求

一个简单的例子
假设现在有多个函数，有的函数是递归的，我希望对这些函数进行微修改，然后打印输出系统在执行函数时，进行的调用过程以及消耗的时间

以下面两个函数为例，

# 非递归的import timedef snooze(seconds): time.sleep(seconds)# 递归的def factorial(n): return 1 if n < 2 else n * factorial(n-1)

2.2 直接方式

2.2.1 直接修改每个函数内部的实现

当函数很少的时候，可以直接对函数内部进行修改，使其达到打印输出的功能

如下这样改造，

import timedef 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 timedef printFunc1(elapsedTime, funcName, inputParam, outputParam):
print("[%s] %s(%s) -> %s".format(elapsedTime, funcName, str(inputParam), str(outputParam)))
def printFunc2(*args, **kwargs):
passdef 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装饰器来对以下的函数进行装饰@decoratedef target(): print( "running target()")# 实际上，上述写法是一种语法糖，它等价于def target(): print( "running target()" ) target = decorate(target)

可以看到，装饰器是可以调用的对象，其参数是另一个函数（即被装饰的函数）。装饰器可能会处理被装饰的函数，然后把它返回，或者将其替换成另一个函数或可调用对象。

2.3.3 如何解决上述问题

直接上代码，

import timedef 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@clockdef snooze(seconds): time.sleep(seconds)@clockdef 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以函数为输入，输出的也是函数，但是中间加了额外的代码逻辑。

原文链接：https://www.jianshu.com/p/2ab60b84f41e