精华内容
下载资源
问答
  • python中的工厂模式和单例模式的例子


    设计模式是面向对象语言特有的内容,是在面临某一类问题时候固定的做法,设计模式有很多种,比较流行的是:GOF(Goup Of Four)23 种设计模式。
    两个最常用的模式:工厂模式和单例模式。

    1.工厂模式

    工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
    工厂模式如下例:

    class CarFactory:
        def createCar(self, brand):
            if brand == "奔驰":
                return Benz()
            elif brand == "宝马":
                return BMW()
            elif brand == '比亚迪':
                return BYD()
            else:
                return "未知品牌,无法创建"
    
    
    class Benz:
        pass
    class BMW:
        pass
    class BYD:
        pass
    factory = CarFactory()
    c1 = factory.createCar("奔驰")
    c2 = factory.createCar("宝马")
    

    2.单例模式

    单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。
    单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久驻留内存中,从而极大的降低开销。
    单例模式有多种实现的方式,推荐重写__new__()的方法,如下例实现:

    class MySingleton:
        __obj = None
        __init_flag = True
    
        def __new__(cls, *args, **kwargs):
            if cls.__obj == None:
                cls.__obj = object.__new__(cls)
            return cls.__obj
    
        def __init__(self, name):
            if MySingleton.__init_flag:
                print("init....")
            self.name = name
            MySingleton.__init_flag = False
    

    工厂类定义成“单例”,只需要简单的套用即可实现:

    class CarFactory:
        __obj = None  # 类属性
        __init_flag = True
    
        def create_car(self, brand):
            if brand == "奔驰":
                return Benz()
            elif brand == "宝马":
                return BMW()
            elif brand == "比亚迪":
                return BYD()
            else:
                return "未知品牌,无法创建"
    
        def __new__(cls, *args, **kwargs):
            if cls.__obj == None:
                cls.__obj = object.__new__(cls)
                return cls.__obj
    
        def __init__(self):
            if CarFactory.__init_flag:
                print("init CarFactory....")
                CarFactory.__init_flag = False
    class Benz:
        pass
    class BMW:
        pass
    class BYD:
        pass
    
    展开全文
  • 设计模式_工厂模式实现 设计模式是面向对象语言特有的内容,是我们在...工厂模式实现了创建者调用者的分离,使用专门的工厂类将选择实现类、创建对象进 行统一的管理控制。 #测试工厂模式 class CarFactory: ...

    设计模式_工厂模式实现

    设计模式是面向对象语言特有的内容,是我们在面临某一类问题时候固定的做法,设计 模式有很多种,比较流行的是:GOF(Goup Of Four)23 种设计模式。当然,我们没有必要全部学习,学习几个常用的即可。

    工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进 行统一的管理和控制。

    #测试工厂模式
    class CarFactory:
        def create_car(self,brand):
            if brand=='奔驰':
                return Benz()
            elif brand=='宝马':
                return BMW()
            elif brand=='比亚迪':
                return BYD()
            else:
                return '未知品牌无法创建'
    
    class Benz:
        pass
    class BMW:
        pass
    class BYD:
        pass
    
    factory=CarFactory()
    c1=factory.create_car('奔驰')
    c2=factory.create_car('宝马')
    print(c1)
    print(c2)
    

    运行结果:
    < main__.Benz object at 0x021C5770>
    < main__.BMW object at 0x021C5790>

    设计模式_单例模式实现

    单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。

    单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久驻留内存中,从而极大的降低开销。

    单例模式有多种实现的方式,我们这里推荐重写 new ()的方法。

    #测试单例模式
    class MySingleton:
        __obj=None#类属性
        __init__flag=True
    
        def __new__(cls, *args, **kwargs):
            if cls.__obj==None:
                cls.__obj=object.__new__(cls)
            return cls.__obj
    
        def __init__(self,name):
            if MySingleton.__init__flag:
                self.name=name
                print('init....')
                MySingleton.__init__flag=False
    
    a=MySingleton('aa')
    b=MySingleton('bb')
    print(a)
    print(b)
    

    运算结果:
    在这里插入图片描述
    设计模式称之为“模式”,就是一些固定的套路。我们很容易用到其他场景上,比如前面讲的工厂模式,我们需要将工厂类定义成“单例”,只需要简单的套用即可实现:

    #测试工厂模式改变为单例模式
    class CarFactory:
        __obj=None#类属性
        __init__flag=True
    
        def create_car(self,brand):
            if brand=='奔驰':
                return Benz()
            elif brand=='宝马':
                return BMW()
            elif brand=='比亚迪':
                return BYD()
            else:
                return '未知品牌无法创建'
    
        def __new__(cls, *args, **kwargs):
            if cls.__obj == None:
                cls.__obj = object.__new__(cls)
            return cls.__obj
    
        def __init__(self):
            if CarFactory.__init__flag:
                print('init....')
                CarFactory.__init__flag = False
    
    class Benz:
        pass
    class BMW:
        pass
    class BYD:
        pass
    
    factory=CarFactory()
    c1=factory.create_car('奔驰')
    c2=factory.create_car('宝马')
    print(c1)
    print(c2)
    
    factory2=CarFactory()
    print(factory)
    print(factory2)
    

    运算结果:
    在这里插入图片描述

    展开全文
  • 工厂模式: 解耦 定义类或方法,让其功能越单一越好 单类模式

    工厂模式:

    解耦
    定义类或方法,让其功能越单一越好

    #!/usr/bin/python
    #coding:utf-8
    class Cake():
        def __init__(self,weidao="默认"):
    
            self.taste=weidao
    
    class AppleCake(object):
        def __init__(self,weidao="苹果"):
            self.taste = weidao
    
    class OrangeCake(object):
        def __init__(self,weidao="橘子"):
            self.taste = weidao
    
    
    
    class CakeStore(object):
        def taste(self,weidao):
            if weidao == "苹果":
                cake = AppleCake()
                print("------味道%s------"%cake.taste)
            elif weidao == "橘子":
    	    cake = OrangeCake()
                print("---------味道%s------"%cake.taste)
    haolilai = CakeStore()
    haolilai.taste("橘子")
    
    [root@server python]# python 工厂方法.py 
    ---------味道橘子------
    

    在这个代码中如果我们想再增加一种口味的蛋糕就需要在CakeStore()这个类里面增加代码,在外面再写一个类,这样不太好

    工厂方法:

    class CakeFactory(object):
        def CreateCake(self,weidao):
            if weidao == "苹果":
                cake = AppleCake()
            elif weidao == "橘子":
                cake = OrangeCake()
            return cake  #这里一定要有返回值,因为我们需要这个函数的执行结果在另一个函数里面调用
    
    class CakeStore(object):
        def __init__(self):
            self.factory = CakeFactory()
        def taste(self,weidao):
            cake = self.factory.CreateCake(weidao)
            print("-----品尝味道:%s-----"%cake.taste)
    haolilai = CakeStore()
    haolilai.taste("橘子")
    
    [root@server python]# python 工厂方法.py 
    -----品尝味道:橘子-----
                                                                
    

    单例模式
    __new__方法

    class Test(object):
        #初始化功能,往往完成对象属性的设置
    	def __init__(self):
            self.num = 100
            print("-------100------")
            print(self)
        #完成创建一个对象
        #当a = Test()执行的时候,是先调用__new__方法完成创建对象,然后紧接着调用__init__(),一般不重写new方法
    
        def __new__(cls):  
            print("---new--------")
            print(cls)
            return super().__new__(cls) #cls表示当前类,即创建一个当前类的对象。 返回创建的对象,这样__init__中的self就可以调用此对象。
        def __str__(self):
            return "hahah"
    
    
    a = Test()
    print(a.num)
    print(a)
    
    
    #!/usr/bin/python
    #coding=utf-8
    
    class Singleton(object):
        __instance = None  #类属性,可以通过类名去调用
        __first_init = False
    
        def __new__(cls,age,name):
            if not cls.__instance:
                cls.__instance = object.__new__(cls)  #cls相当于类
            return cls.__instance
    
        def __init__(self,age,name):
            if not self.__first__init:
                self.age = age
                self.name = name
                Singleton.__first__init = True
    
    a = Singleton(18,"haha")
    b = Singleton(8,"hahah")
    

    __new__方法总结:

    • 至少有一个参数cls,代表要实例化的类,此参数在实例化时由python解释器自动提供
    • 必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时需要特别注意,可以return父类__new__出俩的实例,或者是object的__new__出来的实例
    • __init__有一个参数self,就是这个__new__的返回实例,__init__在__new__的基础上可以完成其它初始化的动作,__init__不需要返回值
    • 我们可以将类比作制造商,__new__就是前期的原始材料的购买环节,__init__就是在原有材料的基础上加工、初始化商品环节。
    #!/usr/bin/python4
    #coding:utf-8
    
    class Test(object):
        def __init__(self):
            self.num = 100
            print("---init---")
            print(self)
        def __new__(cls):
            print("---new---")
            print(cls)
            return super().__new__(cls)
    
    #   def __str__(self):
    #       return "xxxx"
    
    a = Test()
    print(a.num)
    print(a)
    

    在这里插入图片描述
    #!/usr/bin/python
    #coding=utf-8

    class Singleton(object):
    __instance = None #类属性,可以通过类名去调用
    __first_init = False

    def __new__(cls,age,name):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)  #cls相当于类
        return cls.__instance
    
    def __init__(self,age,name):
        if not self.__first__init:
            self.age = age
            self.name = name
            Singleton.__first__init = True
    
    a = Singleton(18,"haha")
    b = Singleton(8,"hahah")
    

    单例控制:

    #!/usr/bin/python 
    #coding:utf-8
    class singleton(object):
        __instance = None
        def __new__(cls):
            if cls.__instance == None:
                cls.__instance=object.__new__(cls)   #等价于(super).__new__(cls)
            return cls.__instance
    
    a = singleton()
    b = singleton()
    print(a)
    print(b)
    

    在这里插入图片描述
    在__init__部分完成初始化的控制,只初始化一次。

    展开全文
  • 三、工厂模式 四、策略模式 五、观察者模式 一、引入 程序中设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。 这些解决方案是众多软件开发人员经过相当长的一段时间的试验错误总结出来的。...

    目录

    一、引入

    二、单例模式

    三、工厂模式

    四、策略模式

    五、观察者模式


    一、引入

    程序中设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。

    这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

    二、单例模式

    保证只有一个对象

    练习1

    创建Sun类

    练习2

    优化练习1写法

    练习3

    使用导入模块的方式创建单例对象。

    注意:在python中导入模块就是一种单例模式。

    三、工厂模式

    概念

    工厂模式是一个在软件开发中用来创建对象的设计模式

    当程序运行输入一个“类型”的时候,需要创建于此相应的对象。这就用到了工厂模式。

    在如此情形中,实现代码基于工厂模式,可以达到可扩展,可维护的代码。

    当增加一个新的类型,不再需要修改已存在的类,只增加能够产生新类型的子类。

    使用工厂模式应用场景:不知道用户想要创建什么样的对象

    练习

    创建Factory工厂类。

    四、策略模式

    概念

    策略指的就是为了达到某一目的而采取的多种手段或者方法。

    为了实现软件设计,对象可能会用到多种多样的算法(逻辑)。这些算法甚至会经常改变。如果将这些算法都硬编码到对象中,将会使得对象本身变得臃肿不堪,策略模式很好的实现了将算法与本身对象解耦,从而避免出现上述的问题。

    因此策略模式可以定义为: 

    定义一系列算法(逻辑),将每一个算法封装起来(一个算法创建一个类),并让它们可以相互替换。

    此模式让算法的变化,不会影响到使用算法的客户.

    策略模式的结构

    策略模式包含以下3个角色:

    Context(环境类)

    Strategy(抽象策略类)

    ConcreteStrategy(具体策略类)

    练习

    假设某司维护着一些客户资料,需要在该司有新产品上市或者举行新活动时通知客户。现通知客户的方式有两种:短信通知、邮件通知。应如何设计该系统的客户通知部分?

    为解决该问题,我们先构造客户类,包括客户常用的联系方式和基本信息,同时也包括要发送的内容。

    class Client(object):
    
        name=''
    
        phone=''
    
        email=''
    
        send_way=None
    
        def set_send_way(self,send_way):
    
            self.send_way=send_way
    
        def send_msg(self):
    
            self.send_way.send()

    再构造策略父类

    #发送方式,父类

    class MsgSender(object):
    
        des_code=''
    
        info=''
    
        def send(self):
    
            pass

    #具体发送方式,子类

    class PhoneSend(MsgSender):
    
        def send(self):
    
            print('给{}打电话说{}'.format(self.des_code,self.info))
    
    class EmailSend(MsgSender):
    
        def send(self):
    
            print('给{}发邮件说{}'.format(self.des_code,self.info))

     

    调用部分

    class PhoneSend(MsgSender):
    
        def send(self):
    
            print('给{}打电话说{}'.format(self.des_code,self.info))
    
    class EmailSend(MsgSender):
    
        def send(self):
    
            print('给{}发邮件说{}'.format(self.des_code,self.info))

        

    emailsend=EmailSend()
    
        emailsend.des_code=client.email
    
        emailsend.info='新产品上市了,确定不要来看一下吗?'
    
        client.set_send_way(emailsend)
    
        client.send_msg()

    结果:

    五、观察者模式

    class Monitor(object):
        def __init__(self):
            self.observers=[]
            self.status=''
    
        def attach(self,observer):
            self.observers.append(observer)
        def notify(self):
            '''通知每一个观察者'''
            for observer in self.observers:
                observer.update()
    
    class SleepStudentObserver(object):
        def __init__(self,name,monitoor):
            self.name=name
            self.monitor=monitoor
    
        def update(self):
            print('{},{}赶快起来学习吧'.format(self.monitor.status,self.name))
    
    if __name__ == '__main__':
        monitor=Monitor()
        observerl=SleepStudentObserver('ZS',monitor)
        observer2=SleepStudentObserver('lyc',monitor)
        monitor.attach(observerl)
        monitor.attach(observer2)
        monitor.status='老师来了'
        monitor.notify()

     

    结果:

     

     

    展开全文
  • 工厂模式实现了创建者调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理控制。 #测试工厂模式 class CarFactory: def create_car(self,brand): if brand =="奔驰": return Benz() elif ...
  •  常用的设计模式:工厂模式和单例模式 (一) 工厂模式  该模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制 #测试工厂模式 class CarFactor:#创建工厂类 de...
  • 我们最常用的模式:工厂模式和单例模式(只要在复杂的场景在会使用) 工厂模式 工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。 【例子】 # 工厂模式 '...
  • 1.由于语言的特性不同,设计模式的实现方式实现难度也会不同...4.普通工厂模式可以直接通过传入“类名”作为参数实现 单例模式实例: 12_eg.py class SingleClass: def __init__(self,x=0): self.x = 0 ...
  • 问题:现代化的巧克力工厂具备计算机控制的巧克力锅炉。锅炉做的事情就是把巧克力牛奶融在一起,然后送到下一个阶段,以制成巧克力棒。下边是一个巧克力公司锅炉控制器的代码,仔细...
  • 此问题来自高淇老师python400集讲义课后习题 问题描述: 使用工厂模式、单例模式实现如下需求: (1) 电脑工厂类 ComputerFactory 用于生产电脑 Computer。工厂类使用单例模式, ...# 测试工厂模式和单例模式的整合使用
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 单例模式、简单工厂模式工厂模式、抽象工厂模式、原型模式、建造者模式; 结构类设计模式 装饰器模式、适配器模式、门面模式、组合模式、享元模式、桥梁模式; 行为类设计模式 策略模式、责任链模式、命令模式...
  • class Singleton(object): def __new__(cls,*args,**kwargs): if not hasattr(cls,'_inst'): cls._inst=super(Singleton,cls).__new__(cls,*args,**kwargs) return cls._inst class A(...
  • 1.单例模式 class BmwCar(object): __instance = None def __new__(cls, *args, **kwargs): # super().__new__(cls,*args,**kwargs) if cls.__instance is None: obj = object.__n...
  • 程序中设计模式是软件开发人员在软件开发过程...设计模式主要包括:单例模式工厂模式,策略模式 一、单例模式 保证只有一个对象。 注意:在python中导入模块就是一种单例模式。 练习1:创建Sun类 class Person(obj...
  • 单例模式 确保某一个类中只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,单例模式是一种对象型模式。 方法一: class User(object): __instance =None def __init__(self,name): ...
  • 一. 单例模式(Singleton) 所谓单例模式,也就是说不管什么时候都要确保只有一个对象实例存在。很多情况下,整个系统中只需要存在一个对象,所有的信息...用Python 实现单例模式的方法有很多,先来看第一种方式。 ...
  • 设计模式的概念意义? 一个好的程序员,更多的体现在掌握解决问题的方法,能用自己精通的编程语言解决各种问题,这才是成为一个优秀程序所必备的。 设计模式是面对各种问题进行提炼抽象而形成的解决方案。这些...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 129
精华内容 51
关键字:

python工厂模式和单例模式

python 订阅