常用设计模式

工厂模式

工厂模式是一个在软件开发中用来创建对象的设计模式。
当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工厂模式。在如此情形中，实现代码基于工厂模式，可以达到可扩展，可维护的代码。当增加一个新的类型，不在需要修改已存在的类，只增加能够产生新类型的子类。

class Car(object):
    def __init__(self):
        pass
    def run(self):
        print("跑了")

    def stop(self):
        print("停了")

class WLHG(Car):
    def run(self):
        print("五菱宏光---》》》跑了")

    def stop(self):
        print("五菱宏光---》》》停了")

class ASDMD(Car):
    def run(self):
        print("阿斯顿马丁---》》》跑了")
    def stop(self):
        print("阿斯顿马丁---》》》停了")

class BYD(Car):
    def run(self):
        print("比亚迪---》》》跑了")
    def stop(self):
        print("比亚迪---》》》停了")

class CarFactory(object):
    def __init__(self):
        pass
    def new_car(self,name):
        if name=="五菱宏光":
            wlhg=WLHG()
            return wlhg

        if name=="阿斯顿马丁":
            asdmd=ASDMD()
            return asdmd

        if name == "比亚迪":
            byd = BYD()
            return byd

class CarStore(object):
    def __init__(self,factorty):
        self.factory=factorty

    def order(self,name):
        new_car=self.factory.new_car(name)
        return  new_car

# 去4S店下订单
factory=CarFactory()
car_stoer=CarStore(factory)
#
asdmd=car_stoer.order("阿斯顿马丁")
# 工厂造好车后，拉到4S店
asdmd.run()
asdmd.stop()

策略模式

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

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

class CashNormal(object):
    def __init__(self):
        pass
    def accept_money(self,money):
        return money

class CashReturn(object):
    """满减"""

    def __init__(self,condition,ret):
        self.condition=condition#满减条件
        self.ret=ret#满减金额

    def accept_money(self,money):
        return money(money//self.condition)*self.ret
        # 每满300减50
class CashRate(object):
    """打折"""
    def __init__(self,rate):
        self.rate=rate#打折率
    def accept_money(self,money):
        return money*self.rate

class Context(object):
    def __init__(self,c):
        self.c=c

    def get_reult(self,money):
        return self.c.accept_money(money)

if __name__=='__main__':
    zd={}
    zd[1]=Context(CashNormal())
    zd[2]=Context(CashReturn(300,50))
    zd[3]=Context(CashRate(0.4))
    clue=int(input("请输入你的策略："))

    if clue in zd.keys():
        cs=zd[clue]
    else:
        cs=zd[1]
    money=float(input("你输入的钱："))
    print(cs.get_reult(money))

观察者模式

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

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

"""
      主题
通知者-----》被观察者
"""
class Moniter(object):
    """通知者"""
    def __init__(self):
        self.obervers=[]#保存所有观察者
        self.status=""
    def attach(self,obverser):
        """绑定 每一个观察者"""
        self.obervers.append(obverser)

    def notify(self,):
        """通知每一个观察者"""
        for obverser in self.obervers:
            obverser.update()

class SleepStuentoberver(object):
    def __init__(self,moniter,name):
        self.name=name
        self.moniter=moniter

    def update(self):
        print(f"{self.moniter.status},{self.name}快起来学习")
if __name__=='__main__':

    #通知者
    moniter1=Moniter()
    moniter2=Moniter()
    ob1=SleepStuentoberver(moniter1,"凯爷")
    ob2=SleepStuentoberver(moniter2,"沈爷")
    moniter1.status="你再睡觉扣分"
    # 通知者观察
    moniter1.attach(ob1)
    moniter2.attach(ob2)
    #通知每一位观察者
    moniter1.notify()
    moniter2.notify()