设计模式Python实现

news2025/3/15 18:20:27

过年在家瞎折腾，闲着无聊看到设计模式，于是就想着用Python实现一下。

简单工厂

根据传入的参数决定创建出哪一种产品类的实例。

class CashFactory:
    def createCashAdapter(self, type):
        if type == "满100减20":
            return CashReturn(100, 20)
        elif type == "打八折":
            return CashRebate(0.8)
        else:
            return CashNormal()

class CashSuper(object):
    def __init__(self):
        pass

    @abstractmethod
    def acceptCash(self, money):
        pass


class CashNormal(CashSuper):
    def acceptCash(self, money):
        return money

class CashRebate(CashSuper):
    rebate = 1

    def __init__(self, rebate):
        self.rebate = rebate
        super().__init__()

    def acceptCash(self, money):
        return self.rebate * money

class CashReturn(CashSuper):
    moneyCondition = 0
    moneyReturn = 0

    def __init__(self, moneyCondition, moneyReturn):
        self.moneyCondition = moneyCondition
        self.moneyReturn = moneyReturn
        super().__init__()

    def acceptCash(self, money):
        ret = money
        if money >= self.moneyCondition:
            ret = money - math.floor(money / self.moneyCondition) * self.moneyReturn
        return ret

# 调用工厂
cashFactory = CashFactory()
cashSuper = cashFactory.createCashAdapter(comboValue.get())
result = cashSuper.acceptCash(money)

策略模式

定义一系列算法，所有算法完成相同的工作，实现不同，减少算法间的耦合，由Context确定具体算法，侧重算法的封装。

# context
class CashContext:
    cashSuper = None

    def __init__(self, type):
        if type == "满100减20":
            self.cashSuper = CashReturn(100, 20)
        elif type == "打八折":
            self.cashSuper = CashRebate(0.8)
        else:
            self.cashSuper = CashNormal()

    def getResult(self, money):
        return self.cashSuper.acceptCash(money)

# 调用context
cashContext = CashContext(comboValue.get())
result = cashContext.getResult(money)

代理模式

为其他对象提供一种代理以控制这个对象的访问

# 被代理类
class RealSubject(Subject):

    def request(self):
        print('调用实际方法')

# 代理类
class Proxy(Subject):

    def __init__(self):
        super().__init__()
        self.realSubject = RealSubject()

    def request(self):
        self.preRequest()
        self.realSubject.request()
        self.postRequest()

    def preRequest(self):
        print("调用方法之前")

    def postRequest(self):
        print("调用方法之后")

原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建对象。

# 使用Python的copy包来实现深拷贝和浅拷贝
class Prototype(object):
    def __init__(self):
        print('创建成功')

    def clone(self):
        clone = copy.deepcopy(self)
        return clone


p1 = Prototype()
p2 = p1.clone()

模板方法模式

某一细节上的一系列过程或者一系列步骤，在个别步骤上实现不同时考虑模板方法。

# 抽象类，包含骨架和组成步骤
class AbstractClass(object):
    def template_method(self):
        self.specific_method()
        self.abstract_method()

    def specific_method(self):
        print("调用方法")

    @abstractmethod
    def abstract_method(self):
        raise ValueError('请实现方法')

# 具体方法
class ConcreteClass(AbstractClass):
    def abstract_method(self):
        print("Abstract实现")

# 调用
tm = ConcreteClass()
tm.template_method()

装饰模式

动态给一个对象添加一些额外的职责。

# 抽象接口
class Component(object):

    @abstractmethod
    def operation(self):
        raise ValueError('请实现方法')

# 装饰抽象类
class Decorator(object):
    def __init__(self, component):
        self.component = component

    def operation(self):
        self.component.operation()

class ConcreteDecorator(Decorator):
    def __init__(self, component):
        Decorator.__init__(self, component)

    def operation(self):
        Decorator.operation(self)
        self.addedFunction()

    def addedFunction(self):
        print('addedFunction')

class ConcreteComponent(Component):
    def __init__(self):
        print('创建具体构建对象')

    def operation(self):
        print('调用构建对象方法')

p = ConcreteComponent()
p.operation()
print('---')

d = ConcreteDecorator(p)
d.operation()

外观模式

为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口。

# 外观类
class Facade(object):
    def __init__(self):
        self.sys1 = Subsystem001()
        self.sys2 = Subsystem002()
        self.sys3 = Subsystem003()


    def method(self):
        self.sys1.method()
        self.sys2.method()
        self.sys3.method()

class Subsystem001(object):
    def method(self):
        print('子系统1调用')

class Subsystem002(object):
    def method(self):
        print('子系统2调用')

class Subsystem003(object):
    def method(self):
        print('子系统3调用')

facade = Facade()
facade.method()

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

class Observer(object):

    @abstractmethod
    def response(self):
        pass

class Subject(object):
    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    @abstractmethod
    def notify_observers(self):
        pass

class ConcreteSubject(Subject):

    def notify_observers(self):
        print('观察目标改变')
        print('----------')

        for observer in self.observers:
            observer.response()

class ConcreteObserver1(Observer):

    def response(self):
        print('观察者1变化')

class ConcreteObserver2(Observer):

    def response(self):
        print('观察者2变化')

subject = ConcreteSubject()
obs1 = ConcreteObserver1()
obs2 = ConcreteObserver2()
subject.add_observer(obs1)
subject.add_observer(obs2)
subject.notify_observers()

状态模式

当对象状态改变时允许改变其行为，这个对象看起来像是改变了其类。解决当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列的类中。

class State:

    @abstractmethod
    def handle(self):
        raise ValueError('请实现方法')

class ConcreteState(State):
    def handle(self, context):
        print('当前状态A')
        context.setState(ConcreteState2())

class ConcreteState2(State):
    def handle(self, context):
        print('当前状态B')
        context.setState(ConcreteState3())


class Context(object):
    def __init__(self):
        self.state = ConcreteState()

    def setState(self, state):
        self.state = state

    def getState(self):
        return self.state

    def handle(self):
        self.state.handle(self)

context = Context()
context.handle()
context.handle()

适配器模式

将一个类的接口转换成客户希望的另一种接口

class Target(object):

    @abstractmethod
    def request(self):
        pass

class Adapter:
    def __init__(self):
        pass

    def specificRequest(self):
        print('适配者业务被调用')

class ClassAdapter(Adapter):
    def request(self):
        self.specificRequest()

classAdapter = ClassAdapter()
classAdapter.request()

桥接模式

将抽象部分与它的实现部分分离，是他们都可以独立地变化

class Abstract(object):
    def __init__(self, imple):
        self.imple = imple

    @abstractmethod
    def operation(self):
        pass

class RefinedAbstraction(Abstract):
    def __init__(self,imple):
        super(RefinedAbstraction,self).__init__(imple)

    def operation(self):
        print('扩展抽象角色被访问')
        self.imple.opreationImpl()

class Implementor(object):

    @abstractmethod
    def opreationImpl(self):
        pass

class ConcreteImplementor(Implementor):
    def opreationImpl(self):
        print('实现类角色被访问')

imple = ConcreteImplementor()
abs = RefinedAbstraction(imple)
abs.operation()

命令模式

将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化。

class Command(object):

    @abstractmethod
    def execute(self):
        raise ValueError('请实现方法')

class ConcreateCommand(Command):
    def __init__(self):
        self.receiver = Receiver()

    def execute(self):
        self.receiver.action()

class Invoker(object):
    def __init__(self, command):
        self.command = command

    def call(self):
        print('调用者执行命令')
        self.command.execute()

class Receiver:
    def action(self):
        print('接收者执行命令')

cmd = ConcreateCommand()
ir = Invoker(cmd)
print('客户端发送命令开始')
ir.call()

责任链模式

如果有多个对象有机会处理请求，责任链可使请求的发送者和接受者解耦，请求沿着责任链传递，直到有一个对象处理了它为止。

class Handler(object):
    def __init__(self):
        self.next = None

    def setNext(self, next):
        self.next = next

    def getNext(self):
        return self.next

    @abstractmethod
    def handleRequest(self, request):
        raise ValueError('请实现方法')

class ConcreteHandler1(Handler):
    def handleRequest(self, request):
        if request == "one":
            print('处理者1处理')
        else:
            if self.getNext() is not None:
                self.getNext().handleRequest(request)
            else:
                print('处理完成')

class ConcreteHandler2(Handler):
    def handleRequest(self, request):
        if request == "two":
            print('处理者2处理')
        else:
            if self.getNext() is not None:
                self.getNext().handleRequest(request)
            else:
                print('处理完成')

handler1 = ConcreteHandler1()
handler2 = ConcreteHandler2()
handler1.setNext(handler2)
handler1.handleRequest("two")

中介者模式

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互

class Mediator(object):
    @abstractmethod
    def register(self, colleague):
        raise ValueError('请实现方法')

    @abstractmethod
    def relay(self, colleague):
        raise ValueError('请实现方法')

class ConcreteMediator(Mediator):
    colleagues = []

    def register(self, colleague):
        if not self.colleagues.__contains__(colleague):
            self.colleagues.append(colleague)
            colleague.set_mediator(self)

    def relay(self, colleague):
        for ob in self.colleagues:
            if ob != colleague:
                ob.receive()

class ConcreteColleague1(Colleague):
    def receive(self):
        print("具体类收到请求1")

    def send(self):
        print('具体类发送请求1')
        self.mediator.relay(self)

class ConcreteColleague2(Colleague):
    def receive(self):
        print("具体类收到请求2")

    def send(self):
        print('具体类发送请求2')
        self.mediator.relay(self)

class Colleague(object):
    def __init__(self):
        self.mediator = None

    def set_mediator(self, mediator):
        self.mediator = mediator

    def get_mediator(self):
        return self.mediator

    @abstractmethod
    def receive(self):
        raise ValueError('请实现方法')

    @abstractmethod
    def send(self):
        raise ValueError('请实现方法')

md = ConcreteMediator()
c1 = ConcreteColleague1()
c2 = ConcreteColleague2()
md.register(c1)
md.register(c2)
c1.send()
print('----------------')
c2.send()

享元模式

通过共享的方式高效的支持大量细粒度的对象。

class Flyweight:

    @abstractmethod
    def operation(self, unshared):
        pass

class ConcreteFlyweight(Flyweight):

    def __init__(self, key):
        self.key = key
        print('享元' + key + '被创建')

    def operation(self, unshared):
        print('享元' + self.key)
        print('非享元' + unshared.get_info())

class FlyweightFactory(object):
    _flyweights = {}

    def get_flyweight(self, key):
        if not self._flyweights.get(key):
            self._flyweights[key] = ConcreteFlyweight(key)
        return self._flyweights[key]

class UnsharedConcreteFlyweight:
    def __init__(self, info):
        self.info = info

    def get_info(self):
        return self.info

    def set_info(self, info):
        self.info = info

factory = FlyweightFactory()
f01 = factory.get_flyweight('a')
f02 = factory.get_flyweight('a')
f03 = factory.get_flyweight('b')
f04 = factory.get_flyweight('b')
f01.operation(UnsharedConcreteFlyweight('第1次调用a'))
f01.operation(UnsharedConcreteFlyweight('第2次调用a'))

访问者模式

将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离。

class Memento(object):
    def __init__(self, state):
        self._state = state

    def setState(self, state):
        self._state = state

    def getState(self):
        return self._state

class Caretaker:
    def __init__(self):
        self._memento = None

    def setMemento(self, memento):
        self._memento = memento

    def getMemento(self):
        return self._memento

class Originator:

    def __init__(self):
        self._state = None

    def setState(self, state):
        self._state = state

    def getState(self):
        return self._state

    def createMemento(self):
        return Memento(self._state)

    def restoreMemento(self, memento):
        self.setState(memento.getState())

完整代码点击这里码云

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1453244.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

生成式 AI - Diffusion 模型 （DDPM）原理解析（1）

生成式 AI - Diffusion 模型 （DDPM）原理解析（1）

来自 论文《 Denoising Diffusion Probabilistic Model》（DDPM） 论文链接：https://arxiv.org/abs/2006.11239 Hung-yi Lee 课件整理 简单地介绍diffusion model 的基本概念，diffusion model有很多不同的变形，现在比较…
阅读更多...
适用于电脑和手机的照片恢复工具指南

适用于电脑和手机的照片恢复工具指南

这是适用于 Android、iPhone、Mac 和 Windows 的最佳照片恢复应用程序的指南。 如果您不小心删除了一堆珍贵的照片，请不要担心！ 恢复丢失的照片和数据实际上比您想象的要容易得多。 通过使用照片恢复应用程序，您可以“解锁”存储卡或硬盘驱…
阅读更多...
Java学习第十六节之类与对象的创建和构造器详解

Java学习第十六节之类与对象的创建和构造器详解

类与对象的创建 构造器 package oop;import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MatchGenerator;//Java---->class public class Person {//一个类即使什么都不写，它也会存在一个方法//显示的定义构造器String name;int age;//altinsert构造…
阅读更多...
Code Composer Studio (CCS) - 文件比较

Code Composer Studio (CCS) - 文件比较

Code Composer Studio [CCS] - 文件比较 References 鼠标单击选中一个文件，再同时按住 Ctrl 鼠标左键来选中第二个文件，在其中一个文件上鼠标右击选择 Compare With -> Each Other. References [1] Yongqiang Cheng, https://yongqiang.blog.csdn.n…
阅读更多...
Slider滑动输入条（antd-design组件库）简单使用

Slider滑动输入条（antd-design组件库）简单使用

1.Slider滑动输入条 滑动型输入器，展示当前值和可选范围。 2.何时使用 当用户需要在数值区间/自定义区间内进行选择时，可为连续或离散值。 组件代码来自： 滑动输入条 Slider - Ant Design 3.本地验证前的准备 参考文章【react项目antd组件-de…
阅读更多...
一、ActiveMQ介绍

一、ActiveMQ介绍

ActiveMQ介绍 一、JMS1.jms介绍2.jms消息传递模式3.JMS编码总体架构 二、消息中间件三、ActiveMQ介绍1.引入的原因1.1 原因1.2 遇到的问题1.3 解决思路 2.定义3.特点3.1 异步处理3.2 应用系统之间解耦3.3 实际-整体架构 4.作用 一、JMS 1.jms介绍 jms是java消息服务接口规范&…
阅读更多...
QPaint绘制自定义坐标轴组件00

QPaint绘制自定义坐标轴组件00

最终效果 1.创建一个ui页面，修改背景颜色 鼠标右键->改变样式表->添加颜色->background-color->选择合适的颜色->ok->Apply->ok 重新运行就可以看到widget的背景颜色已经改好 2.创建一个自定义的widget窗口小部件类，class MyChart…
阅读更多...
第五节笔记：LMDeploy 大模型量化部署实践

第五节笔记：LMDeploy 大模型量化部署实践

大模型部署背景 参数用FP16半精度也就是2字节，7B的模型就大约占14G 2.LMDeploy简介 量化降低显存需求量，提高推理速度 大语言模型推理是典型的访问密集型，因为是decoder only的架构，需要token by token的生成，因…
阅读更多...
【2024】如何订阅Netflix奈飞？Netflix奈飞购买教程

【2024】如何订阅Netflix奈飞？Netflix奈飞购买教程

【2024】如何订阅Netflix奈飞？Netflix奈飞购买教程 Netflix奈飞作为全球领先的在线流媒体平台之一，拥有丰富的影视资源和独家内容，成为了人们追剧的热门选择。本文将为您介绍如何订阅Netflix奈飞，并提供详细的购买教程&#xff0…
阅读更多...
String讲解

String讲解

文章目录 String类的重要性常用的方法常用的构造方法String类的比较字符串的查找转化数字转化为字符串字符串转数字 字符串替换字符串的不可变性 字符串拆分字符串截取字符串修改 StringBuilder和StringBuffer String类的重要性 在c/c的学习中我们接触到了字符串，但…
阅读更多...
C++模板详解 —— 函数模板与类模板

C++模板详解 —— 函数模板与类模板

C模板详解 泛型编程函数模板函数模板的概念函数模板的原理 函数模板的实例化函数模板的匹配原则类模板类模板的定义格式类模板的实例化 泛型编程 如果让你编写一个函数，用于两个数的交换。在C语言中，我们会用如下方法： void Swapi(int* p1,…
阅读更多...
关于DVWA靶场Could not connect to the database service的几种解决办法

关于DVWA靶场Could not connect to the database service的几种解决办法

总的来说这个问题都是 config 配置文件没有修改正确 一般修改数据库的用户名和密码与 phpstudy 一致并且添加了 key 就能初始化成功的 但是我还遇到过另一种情况，修改了上面的东西依旧无法连接到数据库 Could not connect to the database service. Please check …
阅读更多...
大数据01-导论

大数据01-导论

零、文章目录 大数据01-导论 1、数据与数据分析 **数据：是事实或观察的结果，是对客观事物的逻辑归纳，是用于表示客观事物的未经加工的原始素材。**数据可以是连续的值，比如声音、图像，称为模拟数据；也可…
阅读更多...
PWM驱动直流电机

PWM驱动直流电机

一、知识补充; 低频时有蜂鸣器响声，加大PWM频率，超出人耳范围就可以听不到，20Hz~20kHz 加大频率-->减小预分频器，从720-->36现在频率就是20kHz这样不会影响占空比？ 二、接线图 三、代码分析 main,c #include…
阅读更多...
正确看待OpenAI大模型Sora

正确看待OpenAI大模型Sora

2月16日凌晨，OpenAI发布了文生视频模型Sora。官方是这样描述的：Sora is an AI model that can create realistic and imaginative scenes from text instructions.Sora一个人工智能模型，它可以根据文本指令创建逼真和富有想象力的场景。Sora…
阅读更多...
云计算基础 -NUMA

云计算基础 -NUMA

UMA UMA中文翻译叫：一致性内存访问 多个CPU通过同一根前端总线（FSB）来访问内存（所有的内存访问都需要通过北桥芯片来完成），若多个CPU访问内存的不同内存单元还是相同内存单元，同一时刻&#x…
阅读更多...
跟着pink老师前端入门教程（JavaScript）-day03

跟着pink老师前端入门教程（JavaScript）-day03

四、数据类型 （一）数据类型简介 1、为什么需要数据类型 在计算机中，不同的数据所需占用的存储空间是不同的，为了便于把数据分成所需内存大小不同的数据，充分利用存储空间，于是定义了不同的数据类型。 …
阅读更多...
SpringBoot+vue2联合打包部署，混合打包部署

SpringBoot+vue2联合打包部署，混合打包部署

SpringBootvue2联合部署，混合部署 前端工程和后端工程目前是都是相对独立性的模式进行开发的。 打包机 只拥有maven，没有nodejs 软件工程场景： 前后端工程在同一个父工程下面，作为一个子工程存在，各自独立开发。前…
阅读更多...
Mysql知识点汇总

Mysql知识点汇总

Mysql知识点汇总 1. Mysql基本场景的简单语句。2. Mysql的增删改查，统计表中的成绩最好的两个同学的名字，年级等。3：请使用多种方法查询每个学生的每门课分数>80的学生姓名4、order by，group by，子查询4.1、having和…
阅读更多...
政安晨：【示例演绎】【Python】【Numpy数据处理】快速入门（一）

政安晨：【示例演绎】【Python】【Numpy数据处理】快速入门（一）

简介 NumPy是SciPy家族的成员之一。 SciPy家族是一个专门应用于数学、科学和工程领域的开源Python生态圈，或者说是一个由多个Python库组成的集合，用于解决科学计算中的各种问题。这些库构成了一个功能强大的科学计算工具箱，可以进行数值计算…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023