设计模式 python

Mastering Python Design Patterns


工厂模式

  • 工厂方法:
    • 调用一个类或者一个函数时,只需要明白输入和输出,而不必关心内部的实现过程。
  • 抽象工厂:
    • 单个类内包括多个函数;单个类内包括多种方法。
使用场景:
  • 对象之间的解耦
  • 优化性能和资源占用
  • 单步类对象的创建
示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Compute:
def add(a, b):
return a + b

def reduce(a, b):
return a - b


if __name__ == '__main__':
a = 2
b = 1

sum_ab = Compute.add(a, b)
print(sum_ab)
reduce_ab = Compute.reduce(a, b)
print(reduce_ab)


# result:
# 3
# 1

建造者模式

  • 一个对象的创建需要多个步骤,并且不同步骤产生不同的表现。
使用场景:
  • 创建复杂对象
  • 要求一个对象有不同的表现,且对象的构造与表现解耦

原型模式

  • 创建一个对象的克隆,输入一个对象,返回一个对象的副本(改变副本不会对原型造成影响)
使用场景:
  • 当创建一个浅副本时,副本依赖引用的原型(提升应用性能和优化内存,但需要小心修改数据)
  • 当创建一个深副本时,副本不依赖引用的原型,并复制所有原型
示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import copy


dict1 = {'num': [1, 2, 3]}

dict2 = copy.copy(dict1)
dict3 = copy.deepcopy(dict1)

dict1['num'].remove(1)

print(dict1)
print(dict2)
print(dict3)


# result:
# {'num': [2, 3]}
# {'num': [2, 3]}
# {'num': [1, 2, 3]}

适配器模式

  • 是一种结构型设计模式,实现两个不兼容接口之间的兼容
使用场景:
  • 让新的插件用在旧的代码上或者让旧的插件用在新的代码上。
示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def main(a, b):
return a + b


def adapter(list_):
return main(list_[0], list_[1])


if __name__ == '__main__':
a = 1
b = 2
c = main(a, b)
print(c)

list_ = [1, 2]
c = adapter(list_)
print(c)


# result:
# 3
# 3

修饰器模式

  • 动态(运行时)扩展一个对象的功能(继承关系是静态的)。
使用场景:
  • 扩展一个对象的行为,无需继承,一个父类可以修饰成为多个不同的子类。
示例:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def fun_1(fun):
fun()
print('fun 1')


@fun_1
def fun_2():
print('fun 2')


# result:
# fun 2
# fun 1


# 执行顺序fun_1(fun_2())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
def fun_1(func):
def main():
print("fun_1 main")
func()
return main # 调用main函数


# 老方法
def fun_2():
print("fun_2")


fun_old = fun_1(fun_2) # 装饰


# 新方法
@fun_1
def fun_3():
print('fun_3')


if __name__ == '__main__':
fun_old()
# 执行顺序fun_2(fun_1())

print('-----')

fun_3()
# 执行顺序fun_3(fun_1())


# result:
# fun_1 main
# fun_2
# -----
# fun_1 main
# fun_3

外观模式

  • 调用一个复杂系统时,不必考虑内部的复杂实现,只需要了解使用方法和API(像是工厂模式的进阶吧)
使用场景:
  • 隐藏系统复杂性的方式

享元模式

  • 通过为相似对象引入数据共享来最小化内存,提升性能
使用场景:
  • 在应用需要创建大量的计算代价大但共享许多属性的对象时

模型-视图-控制器模式

  • 每个部分有明确的职责,模型负责数据访问,控制器负责控制过程,视图时模型的表现
使用场景:
  • Web框架(MVC)

代理模式

  • 使用代理对象在访问实际对象之前执行重要操作
使用场景:
  • 远程代理
  • 虚拟代理
  • 防护代理
  • 智能代理

责任链模式

  • 发送方可直接访问链中的首个节点。若首个节点不能处理请求,则转发给下一个节点,如此直到请求被某个节点处理或者整个链遍历结束

命令模式

  • 将一个操作(撤销、重做、复制、粘贴等)封装成一个对象

解释器模式

  • 用于为高级用户和领域专家提供一个类编 程的框架,但没有暴露出编程语言那样的复杂性

观察者模式

  • 描述单个对象(发布者,又称为主持者或可观察者)和一个或多个对象(订阅者, 又称为观察者)之间的发布-订阅关系

状态模式

  • 状态机是一个抽象机器,具有两个主要部分:状态和转换。状态是指一个系统的当前状况。 一个状态机在任意时间点只会有一个激活状态;转换是指从当前状态到一个新状态的切换。

策略模式

  • 使用多种算法来解决问题,最终采用最优的

模板模式

  • 在实现结构相近的算法时,可以使用模板模式来消除冗 余代码。
Donate comment here