设计模式Python实现

苜蓿花乐园2024-02-18 11:35

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

简单工厂

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

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确定具体算法，侧重算法的封装。

python 复制代码 
# 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)

代理模式

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

python 复制代码 
# 被代理类
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 复制代码 
# 使用Python的copy包来实现深拷贝和浅拷贝
class Prototype(object):
    def __init__(self):
        print('创建成功')

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


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

模板方法模式

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

python 复制代码 
# 抽象类，包含骨架和组成步骤
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()

装饰模式

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

python 复制代码 
# 抽象接口
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()

外观模式

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

python 复制代码 
# 外观类
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()

观察者模式

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

python 复制代码 
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()

状态模式

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

python 复制代码 
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()

适配器模式

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

python 复制代码 
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()

桥接模式

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

python 复制代码 
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()

命令模式

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

python 复制代码 
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()

责任链模式

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

python 复制代码 
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")

中介者模式

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

python 复制代码 
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()

享元模式

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

python 复制代码 
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'))

访问者模式

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

python 复制代码 
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())

完整代码点击这里码云

相关推荐
qq_5290252935 分钟前
Torch.gather
python·深度学习·机器学习
数据小爬虫@35 分钟前
如何高效利用Python爬虫按关键字搜索苏宁商品
开发语言·爬虫·python
Cachel wood1 小时前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
終不似少年遊*1 小时前
pyecharts
python·信息可视化·数据分析·学习笔记·pyecharts·使用技巧
Python之栈1 小时前
【无标题】
数据库·python·mysql
袁袁袁袁满2 小时前
100天精通Python（爬虫篇）——第113天：‌爬虫基础模块之urllib详细教程大全
开发语言·爬虫·python·网络爬虫·爬虫实战·urllib·urllib模块教程
老大白菜2 小时前
Python 爬虫技术指南
python
古希腊掌管学习的神3 小时前
[搜广推]王树森推荐系统——矩阵补充&最近邻查找
python·算法·机器学习·矩阵
LucianaiB4 小时前
探索CSDN博客数据：使用Python爬虫技术
开发语言·爬虫·python
大圣数据星球5 小时前
Fluss 写入数据湖实战
大数据·设计模式·flink
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10红米手机使用google play