[TOC]
本文为笔记
原视频:https://www.bilibili.com/video/BV19541167cn?p=1
设计模式
设计模式:对软件设计中普遍存在(反复出现)的各种问题,所提出的解决方案。每一个设计模式系统的命名、解释和评价面向对象 系统中一个重要的和重复出现的设计。
“四人帮”(Gang of four,Gof)
Erich Gamma,Richard Helm,Ralph Johnson,JohnVissides
《设计模式:可复用面向对象软件的基础》
面向对象
接口
代码例子:
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
| from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): """ 抽象方法,在实现的类中必须实现的方法。限制实现接口的类必须按照接口给定的调用方式实现这些方法 :param money: :return: """ pass
class Alipay(Payment): def pay(self, money): """ 实现接口类中的必须实现的方法 :param money: :return: """ print("支付宝支付了{0}元!".format(money))
class WechatPay(Payment): def pay(self, money): """ 实现接口类中的必须实现的方法 :param money: :return: """ print("微信支付了%d元!" % (money))
a = Alipay() w = WechatPay() a.pay(100) w.pay(100)
|
面向对象的 SOLID 原则
1 开放封闭原则
一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。即软件实体应该在不修改原代码的情况下进行修改。
2 里氏替换原则
所有引用父类的地方必须能透明地使用其子类地方必须能透明地使用其子类的对象,一个简单的例子加强理解
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| class User(object): def print_name(self): pass
class VipUser(User): def print_name(self): """ 保证参数和返回值类型需要和父类一样 :return: """ pass def print_name(u): """ 不论使用User还是继承User的VipUser,调用的方式是一样的。这就要求User和VipUser的方法参数和返回值类型是一样的 :param u: :return: """ u.print_name()
|
3 依赖倒置原则
高层模块不应该依赖底层模块,二者都应该依赖抽象。抽象不应该依赖细节,细节应该应该依赖抽象。**要针对接口编程,而不是针对实现变成
**。通过例子加强理解:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
| from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): pass
class Alipay(Payment): def pay(self, money): print("支付宝支付了{0}元!".format(money))
class WechatPay(Payment): def pay(self, money): print("微信支付了%d元!" % (money))
a = Alipay() w = WechatPay() a.pay(100) w.pay(100)
|
4 接口隔离原则
使用多个专门的接口,而不使用单一的总结口,高层的代码不应该依赖那些它不需要的接口。通过例子加强理解:
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
| from abc import ABCMeta, abstractmethod
class LandAnimal(metaclass=ABCMeta): @abstractmethod def walk(self): pass
class WaterAnimal(metaclass=ABCMeta): @abstractmethod def swim(self): pass
class SkyAnimal(metaclass=ABCMeta): @abstractmethod def fly(self): pass
class Tiger(LandAnimal): def walk(self): pass
class Frog(LandAnimal, WaterAnimal): def walk(self): pass
|
5 单一职责原则
不要存在多于一个导致类变更的原因,一个类只负责一项职责,一个类只做一件事。**把面向过程的代码放到类中,虽然用到了类,但不是面向对象
**。
设计模式分类
- 创建型模式:工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式;
- 结构性模式:适配器模式、桥模式、组合模式、装饰模式、外观模式、享元模式、代理模式;
- 行为型模式:解释器模式、责任链模式、命令模式、迭代器模式、中介模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式。
创建型模式
1 简单工厂模式
- 内容:简单工厂模式不是23中设计模式中的,但是必须要知道。简单工厂模式不直接向客户端暴露对象创建的细节,而是通过一个工厂类来负责创建产品类的实例。
- 角色:工厂角色、抽象产品角色、具体产品角色。
代码示例
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 38 39 40 41
| from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): pass
class Alipay(Payment): def __init__(self, use_huabei=False): self.use_huabei = use_huabei
def pay(self, money): if self.use_huabei == True: print("花呗支付了{0}元!".format(money)) else: print("支付宝余额支付了{0}元!".format(money))
class WechatPay(Payment): def pay(self, money): print("微信支付了%d元!" % (money))
class PaymentFactory: def ctreate_payment(self, method): if method == 'Alipay': return Alipay() elif method == 'WechatPay': return WechatPay() elif method == 'HuabeiPay': return Alipay(use_huabei=True) else: raise TypeError('No such payment named %s' % method)
pf = PaymentFactory() p = pf.ctreate_payment('HuabeiPay') p.pay(100)
|
- 优点
- 缺点
- 违反了单一职责原则,将创建逻辑集中到了一个工厂类里
- 当添加新产品时,需要修改工厂类代码,违反了开闭原则
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 38 39 40 41 42 43 44
| from abc import ABCMeta, abstractmethod
class Payment(metaclass=ABCMeta): @abstractmethod def pay(self, money): pass
class Alipay(Payment): def __init__(self, use_huabei=False): self.use_huabei = use_huabei
def pay(self, money): if self.use_huabei == True: print("花呗支付了{0}元!".format(money)) else: print("支付宝余额支付了{0}元!".format(money))
class WechatPay(Payment): def pay(self, money): print("微信支付了%d元!" % (money))
class PaymentFactory(metaclass=ABCMeta): @abstractmethod def create_payment(self): pass
class AlipayFactory(PaymentFactory): def create_payment(self): return Alipay()
class WechatPayFactory(PaymentFactory): def create_payment(self): return Alipay()
class HuabeiFactory(PaymentFactory): def create_payment(self): return Alipay(use_huabei=True)
hfp = HuabeiFactory().create_payment() hfp.pay(100)
|
- 优点
- 每个具体产品都对应一个具体工厂类,不需要修改工厂代码
- 隐藏了对象创建的实现细节
- 缺点
- 每增加一个具体产品类,就必须增加一个相应的具体工厂类
3 抽象工厂模式
- 内容:定义一个工厂类的接口让工厂子类来创建一系列相关或者相互依赖的对象。
- 例子:生产一部手机如果说只需要手机壳、CPU和操作系统这三个类对象,其中每个类对象都有不同的种类。
- 相比工厂方法模式,
抽象工厂模式中的每一个具体工厂都生产一套产品
。
- 角色
- 抽象工厂角色
- 具体工厂角色
- 抽象产品角色
- 具体产品角色
- 客户端
- 优点
- 将客户端与类的具体实现分离
- 每个工厂创建了一个完整的产品系列,使得易于交换产品系列
- 有利于产品一致性(即产品之间的约束关系)
- 缺点
代码示例:
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
| from abc import ABCMeta, abstractmethod
class PhoneShell(metaclass=ABCMeta): @abstractmethod def show_shell(self): pass
class PhoneCPU(metaclass=ABCMeta): @abstractmethod def show_cpu(self): pass
class PhoneOS(metaclass=ABCMeta): @abstractmethod def show_os(self): pass
class SmallShell(PhoneShell): def show_shell(self): print('普通手机小手机壳')
class BigShell(PhoneShell): def show_shell(self): print('普通手机大手机壳')
class AppleShell(PhoneShell): def show_shell(self): print('苹果手机壳')
class SnapDragonCPU(PhoneCPU): def show_cpu(self): print('骁龙CPU')
class HuaweiCPU(PhoneCPU): def show_cpu(self): print('化为CPU')
class AppleCPU(PhoneCPU): def show_cpu(self): print('苹果CPU')
class AndroidOS(PhoneOS): def show_os(self): print('IOS系统')
class AppleOS(PhoneOS): def show_os(self): print('安卓系统')
class PhoneFactory(metaclass=ABCMeta): @abstractmethod def make_shell(self): pass
@abstractmethod def make_cpu(self): pass
@abstractmethod def make_os(self): pass
class HuaweiFactory(PhoneFactory): def make_shell(self): return SmallShell()
def make_cpu(self): return HuaweiCPU()
def make_os(self): return AndroidOS()
class AppleFactory(PhoneFactory): def make_shell(self): return AppleShell()
def make_cpu(self): return AppleCPU()
def make_os(self): return AppleOS()
class Phone: def __init__(self, shell, cpu, os): self.shell = shell self.cpu = cpu self.os = os
def show_info(self): print('手机信息:') self.shell.show_shell() self.cpu.show_cpu() self.os.show_os()
def make_phone(factory): shell = factory.make_shell() cpu = factory.make_cpu() os = factory.make_os() return Phone(shell, cpu, os)
p = make_phone(HuaweiFactory()) p.show_info() """ 手机信息: 普通手机小手机壳 化为CPU IOS系统 """
|
4 建造者模式
- 内容:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
- 角色
建造者模式与抽象工厂模式相似,也用来创建复杂对象,主要区别是建造者模式着重一步步构造一个复杂对象(控制顺序)。而抽象工厂模式着重于多个系列的产品对象
- 优点
- 隐藏了一个产品内部结构与装配
- 将构造代码和表示代码分开
- 可以对构造过程进行更精细的控制
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
| from abc import ABCMeta, abstractmethod
class Player: def __init__(self, face=None, body=None, arms=None, legs=None): self.face = face self.body = body self.arms = arms self.legs = legs
def __str__(self): return '%s,%s,%s,%s' % (self.face, self.body, self.arms, self.legs)
class PlayerBuilder(metaclass=ABCMeta): @abstractmethod def build_face(self): pass
@abstractmethod def build_body(self): pass
@abstractmethod def build_arms(self): pass
@abstractmethod def build_legs(self): pass
class GirlBuilder(PlayerBuilder): def __init__(self): self.player = Player()
def build_face(self): self.player.face = '漂亮的脸蛋'
def build_body(self): self.player.body = '苗条的身材'
def build_arms(self): self.player.arms = '细细的胳膊'
def build_legs(self): self.player.legs = '大长腿'
class MonsterBuilder(PlayerBuilder): def __init__(self): self.player = Player()
def build_face(self): self.player.face = '绿脸'
def build_body(self): self.player.body = '魁梧的身体'
def build_arms(self): self.player.arms = '粗壮的胳膊'
def build_legs(self): self.player.legs = '粗壮的大腿'
class PlayerDirectory(): def builder_player(self, builder): """ 隐藏了装配过程 :param builder: :return: """ builder.build_face() builder.build_body() builder.build_arms() builder.build_legs() return builder.player
builder = GirlBuilder() director = PlayerDirectory() p = director.builder_player(builder) print(p)
|
5 单例模式
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| class Singleton: def __new__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): cls._instance = super(Singleton, cls).__new__(cls) return cls._instance
class MyClass(Singleton): def __init__(self, a): self.a = a
ms1 = MyClass(1) ms2 = MyClass(2) print(ms1.a, ms2.a) print(id(ms1), id(ms2)) """ 2 2 139843914173312 139843914173312 """
|
创建型模式小结
- 抽象工厂模式和建造者模式相比于简单工厂模式和工厂方法模式而言更加灵活也更加复杂
- 通常情况下,软件设计以简单工厂模式或工厂方法模式开始,当发现设计需要更大的灵活性的时候,则向更加复杂的设计模式演化
结构性模式
1 适配器模式
- 内容:将一个类的接口转换成客户希望的另外一个接口,适配器使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
- 两种实现方式:
- 角色
- 适用场景
- 想使用一个已经存在的类,而它的接口不符合你的要求
- (对象适配器)想使用一些已经存在的子类,但不可能对每一个都进行子类化以匹配它们的接口,对象适配器可以适配它的父类接口。
类适配器代码示例:
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
| from abc import ABCMeta, abstractmethod
class Payment(object, metaclass=ABCMeta): @abstractmethod def pay(self, money): pass
class Alipay(Payment): def pay(self, money): print('支付了%d' % money)
class BankPay(): def cost(self, money): print('银联支付了%d' % money)
class PaymentAdapter(Payment, BankPay): """ 把不兼容cost转换成pay """
def pay(self, money): self.cost(money)
p = PaymentAdapter() p.pay(100) """ 银联支付了100 """
|
组合:
1 2 3 4 5 6
| class A: pass class B: def __init__(): self.a = A()
|
对象适配器代码示例:
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 38 39
| from abc import ABCMeta, abstractmethod
class Payment(object, metaclass=ABCMeta): @abstractmethod def pay(self, money): pass
class Alipay(Payment): def pay(self, money): print('支付了%d' % money)
class BankPay(): def cost(self, money): print('银联支付了%d' % money)
class ApplePay(): def cost(self, money): print('苹果支付了%d' % money)
class PaymentAdapter(Payment): def __init__(self, payment): self.payment = payment
def pay(self, money): self.payment.cost(money)
p = PaymentAdapter(ApplePay()) p.pay(100) p = PaymentAdapter(BankPay()) p.pay(100) """ 苹果支付了100 银联支付了100 """
|
2 桥模式
一般写法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| class Shape: pass
class Rectangle(Shape): pass
class Circle(Shape): pass
class RedRectangle(Rectangle): pass
class GreenRectangle(Rectangle): pass class RedCircle(Circle): pass
class GreenCircle(Circle): pass
|
代码示例
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 38 39 40 41 42 43 44 45 46 47 48 49
| from abc import ABCMeta, abstractmethod
class Shape(metaclass=ABCMeta): def __init__(self, color): self.color = color
@abstractmethod def draw(self): pass
class Color(metaclass=ABCMeta): @abstractmethod def paint(self, shape): pass
class Rectangle(Shape): name = '长方形'
def draw(self): self.color.paint(self)
class Circle(Shape): name = '圆形'
def draw(self): self.color.paint(self)
class Red(Color): def paint(self, shape): print('画红色的%s' % shape.name)
class Green(Color): def paint(self, shape): print('画绿色的%s' % shape.name)
rectangle = Rectangle(Red()) rectangle.draw() circle = Circle(Green()) circle.draw() """ 画红色的长方形 画绿色的圆形 """
|
3 组合模式
将对象组合成树形结构以表示“部分-整体”的层次结构(特别是结构是递归的),组合模式使得用户对单个对象和组合对象的使用具有一致性。优点是定义了包含基本对象和组合对象的层次结构;简化客户端代码,客户端可以一致地使用组合对象和单个对象;更加容易增加新类型的组件。
- 内容:将对象组合成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性
- 角色
- 适用场景
- 表示“部分-整体”的层次结构(特别是结构是递归的)
- 希望用户忽略组合对象和单个对象的不同,用户统一的使用组合结构中的对象
- 优点
- 定义了包含基本对象和组合对象的层次结构
- 简化客户端代码,客户端可以一致地使用组合对象和单个对象
- 更加容易增加新类型的组件
代码示例
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
| from abc import ABCMeta, abstractmethod
class Graphic(metaclass=ABCMeta): @abstractmethod def draw(self): pass
class Point(Graphic): def __init__(self, x, y): self.x = x self.y = y
def __str__(self): return '点(%s,%s)' % (self.x, self.y)
def draw(self): print(self)
class Line(Graphic): def __init__(self, p1, p2): self.p1 = p1 self.p2 = p2
def __str__(self): return '线段[(%s,%s)]' % (self.p1, self.p2)
def draw(self): print(self)
class Picture(Graphic): def __init__(self, iterable): self.children = [] for g in iterable: self.add(g)
def add(self, graphic): self.children.append(graphic)
def draw(self): for g in self.children: g.draw()
print('------简单图形------') p = Point(1, 2) l1 = Line(Point(1, 2), Point(3, 4)) l2 = Line(Point(5, 6), Point(7, 8)) print(p) print(l1) print(l2) print('------复合图形(p,l1,l2)------')
pic = Picture([p, l1, l2]) pic.draw()
|
4 外观模式
- 内容:为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用
- 角色
- 优点
代码示例
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 38 39 40 41 42 43 44 45 46 47 48
| class CPU: def run(self): print("CPU开始运行")
def stop(self): print("CPU停止运行")
class Disk: def run(self): print("硬盘开始工作")
def stop(self): print("硬盘停止工作")
class Memory: def run(self): print("内存通电")
def stop(self): print("内存通电")
class Computer: def __init__(self): self.cpu = CPU() self.disk = Disk() self.memory = Memory()
def run(self): self.cpu.run() self.disk.run() self.memory.run()
def stop(self): self.cpu.stop() self.disk.stop() self.memory.stop()
computer = Computer() computer.run() computer.stop()
|
5 代理模式
- 内容:为其他对象提供一种代理以控制对这个对象的访问
- 应用场景
- 远程代理:为远程的对象提供代理
- 虚代理:根据需要创建很大的对象
- 保护代理:控制对原始对象的访问,用于对象有不同的访问权限时
- 角色
- 优点
- 远程代理:可以隐藏对象位于远程地址空间的事实
- 虚代理:可以进行优化,例如根据要求创建对象
- 保护代理:允许在访问一个对象时有一些附加的内务处理
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
| from abc import ABCMeta, abstractmethod
class Subject(metaclass=ABCMeta): @abstractmethod def get_content(self): pass
@abstractmethod def set_content(self, content): pass
class RealSubject(Subject): def __init__(self, filename): self.filename = filename print('读取文件内容!') with open(self.filename, 'r', encoding='utf-8') as f: self.content = f.read()
def get_content(self): return self.content
def set_content(self, content): with open(self.filename, 'w', encoding='utf-8') as f: f.write(content)
class protectedProxy(Subject): def __init__(self,filename): self.subj = RealSubject(filename)
def get_content(self): return self.subj.get_content()
def set_content(self, content): raise PermissionError("无写入权限")
class VirtualProx(Subject): def __init__(self,filename): self.filename = filename self.subj = None
def get_content(self): if not self.subj: self.subj = RealSubject(self.filename) return self.subj.get_content()
def set_content(self, content): if not content: self.subj = RealSubject(self.filename) return self.subj.set_content(content)
print("调用 RealSubject") subj = RealSubject('test.txt')
print("调用 VirtualProx") subj2 = VirtualProx('test.txt') print("调用 VirtualProx 中的 get_content") subj2.get_content()
print("调用 protectedProxy") subj3 = protectedProxy('test.txt') print("调用 protectedProxy get_content") subj3.get_content() print("调用 protectedProxy set_content") subj3.set_content("asdasdsad")
""" 调用 RealSubject 读取文件内容! 调用 VirtualProx 调用 VirtualProx 中的 get_content 读取文件内容! 调用 protectedProxy 读取文件内容! 调用 protectedProxy get_content 调用 protectedProxy set_content Traceback (most recent call last): File "C:/Users/six/PycharmProjects/design_mode/设计模式/chain_of_responsibility.py", line 69, in <module> subj3.set_content("asdasdsad") File "C:/Users/six/PycharmProjects/design_mode/设计模式/chain_of_responsibility.py", line 37, in set_content raise PermissionError("无写入权限") PermissionError: 无写入权限
"""
|
行为型模式
1 责任链模式
- 内容:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链并沿着这条链传递该请求,直到有一个对象处理它为止。
- 角色:
- 适用场景
- 有多个对象可以处理一个请求,那个对象处理由运行时决定
- 在不明确接收者的情况下,向多个对象中的一个提交一个请求
- 优点
- 降低耦合度:一个对象无需知道是其他哪一个对象处理其请求
代码示例
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 38 39 40 41 42 43 44 45 46 47 48
| from abc import ABCMeta, abstractmethod
class Handler(metaclass=ABCMeta): @abstractmethod def handle_leave(self, day): pass
class GeneralManager(Handler): def handle_leave(self, day): if day <= 30: print('总经理准假%d' % day) else: print('可以辞职了!')
class DepartmentManager(Handler): def __init__(self): self.next = GeneralManager()
def handle_leave(self, day): if day <= 7: print('项目主管准假%d' % day) else: print('部门经理职权不足') self.next.handle_leave(day)
class ProjectDirector(Handler): def __init__(self): self.next = DepartmentManager()
def handle_leave(self, day): if day <= 3: print('项目主管准假%d' % day) else: print('项目主管职权不足') self.next.handle_leave(day)
day = 20 p = ProjectDirector() p.handle_leave(day) """ 项目主管职权不足 部门经理职权不足 总经理准假20 """
|
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
| from abc import ABCMeta, abstractmethod
class Observer(metaclass=ABCMeta): @abstractmethod def update(self, notice): """ :param notice: Notice类的对象 :return: """ pass
class Notice: def __init__(self): self.observers = []
def attach(self, obs): self.observers.append(obs)
def detach(self, obs): self.observers.remove(obs)
def notify(self): """ 推送 :return: """ for obs in self.observers: obs.update(self)
class StaffNotice(Notice): def __init__(self, company_info): super().__init__() self.__company_info = company_info
@property def company_info(self): return self.__company_info
@company_info.setter def company_info(self, info): self.__company_info = info self.notify()
class Staff(Observer): def __init__(self): self.company_info = None
def update(self, notice): self.company_info = notice.company_info
staff_notice = StaffNotice('初始化公司信息') staff1 = Staff() staff2 = Staff() staff_notice.attach(staff1) staff_notice.attach(staff2)
staff_notice.company_info = '假期放假通知!' print(staff1.company_info) print(staff2.company_info)
staff_notice.detach(staff2) staff_notice.company_info = '明天开会!' print(staff1.company_info) print(staff2.company_info) """ 假期放假通知! 假期放假通知! 明天开会! 假期放假通知! """
|
3 策略模式
- 内容:定义一系列算法,把它们封装起来,并且使它们可以相互替换。本模式使得算法可独立于使用它的客户而变化。
- 角色:
- 优点
- 定义了一系列可重用的算法和行为
- 消除了一些条件语句
- 可以提供形同行为的不同实现
- 缺点
代码示例
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 38 39 40 41 42 43 44 45 46
| from abc import abstractmethod, ABCMeta from datetime import datetime
class Strategy(metaclass=ABCMeta): @abstractmethod def execute(self, data): pass
class FastStrategy(Strategy): def execute(self, data): print("使用较快的策略处理%s" % data)
class SlowStrategy(Strategy): def execute(self, data): print("使用较慢的策略处理%s" % data)
class Context: def __init__(self, strategy, data): self.data = data self.strategy = strategy self.date = datetime.now()
def set_strategy(self, strategy): self.strategy = strategy
def do_strategy(self): self.strategy.execute(self.data)
data = "Hello!"
fast_strategy = FastStrategy() context = Context(fast_strategy, data) context.do_strategy()
slow_strategy = SlowStrategy() context = Context(slow_strategy, data) context.do_strategy() """ 使用较快的策略处理Hello! 使用较慢的策略处理Hello! """
|
4 模板方法模式
代码示例
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 38 39 40 41 42 43 44 45 46
| from abc import ABCMeta, abstractmethod from time import sleep
class Window(metaclass=ABCMeta): @abstractmethod def start(self): pass
@abstractmethod def repaint(self): pass
@abstractmethod def stop(self): pass
def run(self): """ 模板方法(具体方法),这个大逻辑就不需要自己写了 :return: """ self.start() while True: try: self.repaint() sleep(1) except KeyboardInterrupt: break self.stop()
class MyWindow(Window): def __init__(self, msg): self.msg = msg
def start(self): print('窗口开始运行!')
def stop(self): print('窗口停止运行!')
def repaint(self): print(self.msg)
MyWindow("Hello...").run()
|