设计模式-基于python1

preview
试读
12页
设计模式
需积分: 0 0 下载量 147 浏览量 更新于2022-08-03 收藏 220KB PDF 举报
设计模式是软件开发中的一种重要概念，用于解决常见的设计问题并提供可重用的解决方案。在Python中，设计模式同样有着广泛的应用。本篇主要关注的是创建型模式，包括工厂模式、建造者模式和原型模式，以及设计模式的一些基本原则。 1. **工厂模式**：工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，使得代码在不指定具体类的情况下创建对象。工厂模式分为简单工厂、工厂方法和抽象工厂三种。简单工厂模式有一个中心工厂类，负责创建对象；工厂方法模式将对象的创建过程委托给子类决定；抽象工厂模式则关注创建一系列相关或相互依赖的对象，无需指定它们的具体类。 2. **建造者模式**：建造者模式将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。这种模式适用于当对象的构建过程复杂，需要分步骤进行的情况。 3. **原型模式**：原型模式通过复制已有对象来创建新对象，减少了创建新对象的开销。在Python中，可以通过实现`__copy__`和`__deepcopy__`方法实现浅复制和深复制。 设计模式的基本原则是指导软件设计的核心准则： 1. **单一职责原则（SRP）**：一个类应该只有一个引起它变化的原因。这意味着每个类应专注于一个特定的职责，以提高类的内聚性，降低耦合度。 2. **开闭原则（OCP）**：软件实体（类、模块、函数等）应对扩展开放，对修改关闭。意味着在不修改原有代码的情况下，可以通过添加新代码来扩展功能。 3. **里氏替换原则（LSP）**：所有引用基类的地方都能透明地使用其子类对象，子类可以替换掉父类，而不影响程序的正确性。 4. **依赖倒转原则（DIP）**：抽象不应该依赖细节，细节应该依赖抽象。建议依赖于接口而非具体的实现，以增强系统的灵活性和可维护性。 5. **接口隔离原则（ISP）**：客户端不应该被迫依赖它不需要的方法。应该为客户端提供最小粒度的接口，避免提供大而全的接口。 设计模式的学习应该根据个人的项目经验和需求来安排。初学者可以先了解基本概念，随着经验积累，深入理解和应用重要模式。设计模式的应用有助于提高代码质量，增强软件的可扩展性和可维护性。在实践中，可以参考优秀的设计模式资源，如经典的《设计模式：可复用面向对象软件的基础》等书籍，以提升自己的设计能力。
目录目录
学习设计模式的时机与技巧
设计模式的原则
多个设计模式的介绍
实战项目与考题理解设计模式
关于设计模式优秀资源(优秀文章资源及相关书籍推荐)
学习设计模式的时机与技巧学习设计模式的时机与技巧
1. 建议在没有足够项目经验时可以先过一遍，了解基本的概念
2. 当积累一些工作经验后，可以挑选常见重点设计模式进行理解并可以选择历年的考题与项目加深理解
设计模式的原则设计模式的原则
单一职责原则
单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。
单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦
合在一起，当其中一个职责变化时，可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同
时发生改变则可将它们封装在同一类中。
单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，而发现类的多重职责需要设计人员具有较强的分析设计能力和
相关实践经验
开闭原则(Open-Closed Principle, OCP)
一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。
在开闭原则的定义中，软件实体可以指一个软件模块、一个由多个类组成的局部结构或一个独立的类。
为了满足开闭原则，需要对系统进行抽象化设计，抽象化是开闭原则的关键。
里氏替换原则
里氏代换原则(Liskov Substitution Principle, LSP)：所有引用基类（父类）的地方必须能透明地使用其子类的对象
里氏代换原则告诉我们，在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常，反过来则不成立，如果一个软件实体使用的是一个子类对象的话，那么它不一定能够
使用基类对象。例如：我喜欢动物，那我一定喜欢狗，因为狗是动物的子类；但是我喜欢狗，不能据此断定我喜欢动物，因为我并不喜欢老鼠，虽然它也是动物.
里氏代换原则是实现开闭原则的重要方式之一，由于使用基类对象的地方都可以使用子类对象，因此在 程 序 中 尽量使用基类类型来对 对 象 进 行 定 义 ， 而在运行时再确定其子 类 类 型 ， 用在程序 中 尽 量 使 用 基 类 类型来对对象进行定义 ， 而 在 运 行 时 再 确定其子类类型，用
子类对 象 来 替 换 父 类 对 象子类对 象 来 替 换 父 类 对 象
依赖倒转原则(Dependency Inversion Principle, DIP)：
抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。
依赖倒 转 原 则 要 求 我 们 在程序代码中传递参数 时 或 在 关 联 关 系 中，尽量引用层次高的 抽 象 层 类 ， 即 使 用接口和抽象类进行变 量 类 型 声 明 、 参 数类型声明、方法返回类 型 声 明 ， 以依赖倒 转 原 则 要 求 我 们 在程序代码中传递参数 时 或 在 关 联 关 系 中，尽量引用层次高的 抽 象 层 类 ， 即 使 用接口和抽象类进行变 量 类 型 声 明 、 参 数类型声明、方法返回类 型 声 明 ， 以
及数据 类 型 的 转 换 等 ， 而不要用具体类来做这 些 事 情 。 为 了 确 保该原则的应用，一个 具 体 类 应 当 只 实 现接口或抽象类中声明 过 的 方 法 ， 而 不 要给出多余的方法，否则 将 无 法 调 用及数据 类 型 的 转 换 等 ， 而不要用具体类来做这 些 事 情 。 为 了 确 保该原则的应用，一个 具 体 类 应 当 只 实 现接口或抽象类中声明 过 的 方 法 ， 而 不 要给出多余的方法，否则 将 无 法 调 用
到在子 类 中 增 加 的 新 方 法到在子 类 中 增 加 的 新 方 法
在实现依赖倒转原则时，我们需要针对抽象层编程，而将具体类的对象通过依赖注入(DependencyInjection, DI)的方式注入到其他对象中，依赖注入是指当一个对象要与其他对象发生依赖关系
时，通过抽象来注入所依赖的对象。常用的注入方式有三种，分别是：构造注入，设值注入（Setter注入）和接口注入。构造注入是指通过构造函数来传入具体类的对象，设值注入是指通过
Setter方法来传入具体类的对象，而接口注入是指通过在接口中声明的业务方法来传入具体类的对象。这些方法在定义时使用的是抽象类型，在运行时再传入具体类型的对象，由子类对象来覆
盖父类对象
接口隔离原则
接口隔离原则(Interf ace Segregation Principle, ISP)：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口
接口仅仅提供客户端需要的行为，客户端不需要的行为则隐藏起来，应当为客户端提供尽可能小的单独的接口，而不要提供大的总接口。在面向对象编程语言中，实现一个接口就需要实现该接
口中定义的所有方法，因此大的总接口使用起来不一定很方便，为了使接口的职责单一，需要将大接口中的方法根据其职责不同分别放在不同的小接口中，以确保每个接口使用起来都较为方
便，并都承担某一单一角色。接口应该尽量细化，同时接口中的方法应该尽量少，每个接口中只包含一个客户端（如子模块或业务逻辑类）所需的方法即可，这种机制也称为“定制服务”，即为
不同的客户端提供宽窄不同的接口。
迪米特法则
一个软件实体应当尽可能少地与其他实体发生相互作用。
迪米特法则要求我们在设计系统时，应该尽量减少对象之间的交互，如果两个对象之间不必彼此直接通信，那么这两个对象就不应当发生任何直接的相互作用，如果其中的一个对象需要调用另
一个对象的某一个方法的话，可以通过第三者转发这个调用。简言之，就是通过引入一个合理的第三者来降低现有对象之间的耦合度。
在将迪米特法则运用到系统设计中时，要注意下面的几点：在类的划分上，应当尽量创建松耦合的类，类之间的耦合度越低，就越有利于复用，一个处在松耦合中的类一旦被修改，不会对关联
的类造成太大波及；在类的结构设计上，每一个类都应当尽量降低其成员变量和成员函数的访问权限；在类的设计上，只要有可能，一个类型应当设计成不变类；在对其他类的引用上，一个对
象对其他对象的引用应当降到最低。
推设计模式原则讲解比较好的文章链接推荐
设计模式的介绍设计模式的介绍
第一章第一章 创建型模式创建型模式
1.1 工厂模式(工厂方法、抽象工厂、单例模式及三者的区别)(重点)
1.2 建造者模式
1.3 原型模式
第二章第二章 结构型模式结构型模式
2.1 适配器模式(重点)
2.2 修饰器模式(重点)
2.3 外观模式(重点)
2.4 享元模式(重点)
2.5 MVC模型(重点)
2.6 代理设计模式（Proxy design pattern）(重点)
保护/防护代理:用于对处理敏感信息的对象进行访问控制
远程代理：代表一个活跃于远程位置（例如，我们自己的远程服务器或云服务）的对象
虚拟代理：将一个对象的初始化延迟到真正需要使用时进行
智能（引用）代理：通过添加帮助信息（比如，引用计数）来扩展一个对象的行为时，可以使用智能（引用）代理
第三章第三章 行为型模式行为型模式
3.1 责任链模式
3.2 命令模式
3.3 解释器模式
3.4 观察者模式(重点)
3.5 状态模式
3.6 策略模式(重点)
3.7 模板模式(重点)
第一章第一章 创建型模式创建型模式
返回目 录返回目 录
1.1 工厂 模 式工厂 模 式
使用场 景 ：使 用 场 景 ：
设计思 路 ：设 计 思 路 ：
示例代 码 ：示 例 代 码 ：
工厂方 法工厂方 法
import xml.etree.ElementTree as etree
import json
class JSONConnector:
def __init__(self, filepath):
self.data = dict()
with open(filepath, mode='r', encoding='utf-8') as f:
self.data = json.load(f)
@property
def parsed_data(self):
return self.data
class XMLConnector:
def __init__(self, filepath):
self.tree = etree.parse(filepath)
@property
def parsed_data(self):
return self.tree
def connection_factory(filepath):
if filepath.endswith('json'):
connector = JSONConnector
elif filepath.endswith('xml'):
connector = XMLConnector
else:
raise ValueError('Cannot connect to {}'.format(filepath))
return connector(filepath)
def connect_to(filepath):
factory = None
try:
factory = connection_factory(filepath)
except ValueError as ve:
print(ve)
return factory
def main():
sqlite_factory = connect_to('data/person.sq3')
print('=====================')
xml_factory = connect_to('data/person.xml')
xml_data = xml_factory.parsed_data
liars = xml_data.findall(".//{}[{}='{}']".format('person',
'lastName', 'Liar'))
print('found: {} persons'.format(len(liars)))
for liar in liars:
print('first name: {}'.format(liar.find('firstName').text))
print('last name: {}'.format(liar.find('lastName').text))
[print('phone number ({})'.format(p.attrib['type']), p.text) for p in liar.find('phoneNumbers')]
print('==================')
json_factory = connect_to('data/donut.json')
json_data = json_factory.parsed_data
print('found: {} donuts'.format(len(json_data)))
for donut in json_data:
print('name: {}'.format(donut['name']))
print('price: ${}'.format(donut['ppu']))
[print('topping: {} {}'.format(t['id'], t['type'])) for t in donut['topping']]
if __name__ == '__main__':
main()</code></pre>
抽象工厂
class Frog:
def __init__(self, name):
self.name = name
def __str__(self):
return self.name
def interact_with(self, obstacle):
print('{} the Frog encounters {} and {}!'.format(self, obstacle, obstacle.action()))
class Bug:
def __str__(self):
return 'a bug'

剩余11页未读，继续阅读

资源推荐
资源评论
无声远望
  • 粉丝: 1127
  • 资源: 298
上传资源 快速赚钱
voice
center-task 前往需求广场，查看用户热搜

最新资源