python常用的设计模式

设计模式：

设计模式来源于建筑行业,中西方建筑各有自己的风格;每种风格都有自己的建筑方法(套 路); 只要按照不同风格的建筑方法（套路）就能建成不同风格的建筑;简单的说设计模式就是一 种(方法)套路;再比如肯德基麦当劳快餐店为什么全球的口味都一样呢？就是做食品的套路相 同(炸鸡块多长时间都是固定的)。 程序中设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方 案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。使用设计模式是为 了重用代码、让代码更容易被他人理解、保证代码可靠性。

单例模式：

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某 一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象 就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来 读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就 是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个
AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况
下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。 注意：在python中导入模块就是一种单例模式。

#单例模式
class Car(object):
    install=None
    def __new__(cls, *args, **kwargs):
        if cls.install==None:#如果为空就创建内存空间
            cls.install=super().__new__(cls)
        return cls.install 

c=Car()
b=Car()
print(c is b) #不管创建多少实例对象都是同一个内存空间
#>>>True

工厂模式：

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

当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工厂模式。在
如此情形中，实现代码基于工厂模式，可以达到可扩展，可维护的代码。当增加一个新的类 型，不在需要修改已存在的类，只增加能够产生新类型的子类。
使用工厂模式应用场景：当不知道用户想要创建什么样的对象是可以使用工厂模式！
上代码：

#工厂模式

#基类
class Car(object):
    def run(self):
        print("----正在发动隐形")
    def storp(self):
        print("----正在刹车")

#各大汽车工厂
class Bwm(Car):
    def run(self):
        print("-------v8隐形正在发动")
class Ben(Car):
    def run(self):
        print("-------12缸发动机正在启动")
class Hf(Car):
    def run(self):
        print("-------HF正在为您启动爱车")


#相当于汽车工厂
class CarFactory(object):
    def __init__(self):
        pass
    def new_car(self,name):
        if name=='Bwm':
            bwm=Bwm()
            return bwm
        elif name=='Ben':
            ben=Ben()
            return ben
        elif name=='Hf':
            hf=Hf()
            return hf

#相当于4s店的功能
class Car_store(object):
    def __init__(self,faction):
        self.faction=faction
    def order(self,name):
        newcar=self.faction.new_car(name)
        return newcar


chang=CarFactory() #创建汽车工厂的实例对象
store=Car_store(chang) #创建4s店的实例对象 并且将工程的对象引用传进去
h=store.order('Bwm')  # 生产一辆宝马
h.run()

#>>>-------v8隐形正在发动

策略模式：

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

因此策略模式可以定义为： 定义一系列算法(逻辑)，将每一个算法封装起来(一个算法创建 一个类)，并让它们可以相互替换。此模式让算法的变化,不会影响到使用算法的客户. 策略模式的结构
策略模式包含以下3个角色： Context（环境类） Strategy（抽象策略类） ConcreteStrategy（具体策略类）

#策略模式
class CashRate:
    def __init__(self,rate):
        self.rate=rate
    def accept_money(self,money):
        return money * self.rate
class CashReturn:
    def __init__(self,man,jian):
        self.man=man
        self.jian=jian
    def accept_money(self,money):
        return money-(money//self.man)*self.jian
class Cash:
    def __init__(self):
        pass
    def accept_money(self,money):
        return money
class Context:
    def __init__(self,cs):
        self.cs=cs
    def get_result(self,money):
        return self.cs.accept_money(money)

if __name__ == '__main__':
    ls={}
    ls[1]=Context(CashRate(0.7))
    ls[2]=Context(CashReturn(300,50))
    ls[3]=Context(Cash())

    celue=int(input("请输策略："))
    if celue in ls.keys():
        cs=ls[celue]
    else:
        cs=ls[3]

    print(cs.get_result(600))

观察者模式：

观察者模式：又叫发布订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监 听某一个主题对象，这个主题对象的状态发生变化时，会通知所有观察者对象，是他们能自 动更新自己。

具体应用场景：

事件驱动系统是观察者模式的例子。在这种系统中，监听者被用于监听特定事
件。监听者正在监听的事件被创建出来时，就会触发它们。这个事件可以是键入
（键盘的）某个特定键、移动鼠标或者其他。事件扮演发布者的角色，监听者则 扮演观察者的角色。在这里，关键点是单个事件（发布者）可以关联多个监听者
（观察者）

#观察者模式
class Monitor:
    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:
    def __init__(self,name,monitor):
        self.name=name
        self.monitor=monitor
    def update(self):
        print("{},{}起来学习".format(self.monitor.status,self.name))

if __name__ == '__main__':
    monitor=Monitor()
    obs1=SleepStudentObserver('zs',monitor)
    obs2=SleepStudentObserver('ls',monitor)
    monitor.attach(obs1)
    monitor.attach(obs2)
    monitor.status='老师有来了'
    monitor.notify()