#encoding=utf8
import threading
import time#这里使用方法__new__来实现单例模式
class Singleton(object):#抽象单例def __new__(cls, *args, **kw):if not hasattr(cls, '_instance'):orig = super(Singleton, cls)cls._instance = orig.__new__(cls,*args,**kw)return cls._instance
#总线
class Bus(Singleton):lock = threading.RLock()def sendData(self,data):self.lock.acquire()time.sleep(3)print ("Sending Signal Data...",data)self.lock.release()
#线程对象，为更加说明单例的含义，这里将Bus对象实例化写在了run里
class VisitEntity(threading.Thread):my_bus=""name=""def getName(self):return self.namedef setName(self, name):self.name=namedef run(self):self.my_bus=Bus()self.my_bus.sendData(self.name)if  __name__=="__main__":for i in range(20):print("Entity %d begin to run..."%i)my_entity=VisitEntity()my_entity.setName("Entity_"+str(i))my_entity.start()

'''
快餐点餐系统
想必大家一定见过类似于麦当劳自助点餐台一类的点餐系统吧。
在一个大的触摸显示屏上，有三类可以选择的上餐品：汉堡等主餐、小食、饮料。
当我们选择好自己需要的食物，支付完成后，订单就生成了。
下面，我们用今天的主角--工厂模式--来生成这些食物的逻辑主体。
'''# ------------------------商品(汉堡)
class Burger():name=""price=0.0def getPrice(self):return self.pricedef setPrice(self,price):self.price=pricedef getName(self):return self.nameclass cheeseBurger(Burger):def __init__(self):self.name="cheese burger"self.price=10.0class spicyChickenBurger(Burger):def __init__(self):self.name="spicy chicken burger"self.price=15.0# ------------------------商品(小吃)
class Snack():name = ""price = 0.0type = "SNACK"def getPrice(self):return self.pricedef setPrice(self, price):self.price = pricedef getName(self):return self.nameclass chips(Snack):def __init__(self):self.name = "chips"self.price = 6.0class chickenWings(Snack):def __init__(self):self.name = "chicken wings"self.price = 12.0# ------------------------商品(饮料)
class Beverage():name = ""price = 0.0type = "BEVERAGE"def getPrice(self):return self.pricedef setPrice(self, price):self.price = pricedef getName(self):return self.nameclass coke(Beverage):def __init__(self):self.name = "coke"self.price = 4.0class milk(Beverage):def __init__(self):self.name = "milk"self.price = 5.0# ------------------------食物工厂(定义食品类别以及统一实例化方式)
class foodFactory():type = ""def createFood(self,foodClass):print (self.type," factory produce a instance.")foodIns=foodClass()return foodIns
class burgerFactory(foodFactory):def __init__(self):self.type="BURGER"
class snackFactory(foodFactory):def __init__(self):self.type="SNACK"
class beverageFactory(foodFactory):def __init__(self):self.type="BEVERAGE"# 简单工厂模式(省去实例化工厂类的过程,直接通过简单工厂实例化商品)
class simpleFoodFactory():@classmethoddef createFood(cls,foodClass):print ("Simple factory produce a instance.")foodIns = foodClass()return foodInsif __name__ == "__main__":# 工厂模式# burger_factory=burgerFactory()# snack_factorry=snackFactory()# beverage_factory=beverageFactory()# cheese_burger=burger_factory.createFood(cheeseBurger)# print (cheese_burger.getName(),cheese_burger.getPrice())# chicken_wings=snack_factorry.createFood(chickenWings)# print (chicken_wings.getName(),chicken_wings.getPrice())# coke_drink=beverage_factory.createFood(coke)# print (coke_drink.getName(),coke_drink.getPrice())# 简单工厂模式(省去了实例化工厂类的过程)spicy_chicken_burger = simpleFoodFactory.createFood(spicyChickenBurger)print (spicy_chicken_burger.getName(),spicy_chicken_burger.getPrice())'''
还是在上述例子中，createFood方法中必须传入foodClass才可以指定生成的food实例种类，
如果，将每一个细致的产品都建立对应的工厂（如cheeseBurger建立对应一个cheeseBurgerFactory），
这样，生成食物时，foodClass也不必指定。事实上，此时，burgerFactory就是具体食物工厂的一层抽象。
这种模式，就是抽象工厂模式。
'''

# ------------------------商品(汉堡)
class Burger():name=""price=0.0def getPrice(self):return self.pricedef setPrice(self,price):self.price=pricedef getName(self):return self.nameclass cheeseBurger(Burger):def __init__(self):self.name="cheese burger"self.price=10.0class spicyChickenBurger(Burger):def __init__(self):self.name="spicy chicken burger"self.price=15.0# ------------------------商品(小吃)
class Snack():name = ""price = 0.0type = "SNACK"def getPrice(self):return self.pricedef setPrice(self, price):self.price = pricedef getName(self):return self.nameclass chips(Snack):def __init__(self):self.name = "chips"self.price = 6.0class chickenWings(Snack):def __init__(self):self.name = "chicken wings"self.price = 12.0# ------------------------商品(饮料)
class Beverage():name = ""price = 0.0type = "BEVERAGE"def getPrice(self):return self.pricedef setPrice(self, price):self.price = pricedef getName(self):return self.nameclass coke(Beverage):def __init__(self):self.name = "coke"self.price = 4.0class milk(Beverage):def __init__(self):self.name = "milk"self.price = 5.0class order():burger=""snack=""beverage=""def __init__(self,orderBuilder):self.burger=orderBuilder.bBurgerself.snack=orderBuilder.bSnackself.beverage=orderBuilder.bBeveragedef show(self):print ("Burger:%s"%self.burger.getName())print ("Snack:%s"%self.snack.getName())print ("Beverage:%s"%self.beverage.getName())class orderBuilder():bBurger=""bSnack=""bBeverage=""def addBurger(self,xBurger):self.bBurger=xBurgerdef addSnack(self,xSnack):self.bSnack=xSnackdef addBeverage(self,xBeverage):self.bBeverage=xBeveragedef build(self):return order(self)class orderDirector():order_builder=""def __init__(self,order_builder):self.order_builder=order_builderdef createOrder(self,burger,snack,beverage):self.order_builder.addBurger(burger)self.order_builder.addSnack(snack)self.order_builder.addBeverage(beverage)return self.order_builder.build()if  __name__=="__main__":# order_builder=orderBuilder()# order_builder.addBurger(spicyChickenBurger())# order_builder.addSnack(chips())# order_builder.addBeverage(milk())# order_1=order_builder.build()# order_1.show()# 统一调度orderDirector = orderDirector(orderBuilder())display_show = orderDirector.createOrder(spicyChickenBurger(),chips(),milk())display_show.show()

'''
大家如果用过类似于Photoshop的平面设计软件，一定都知道图层的概念。
图层概念的提出，使得设计、图形修改等操作更加便利。
设计师既可以修改和绘制当前图像对象，又可以保留其它图像对象，逻辑清晰，且可以及时得到反馈。
本节内容，将以图层为主角，介绍原型模式。
'''from copy import copy, deepcopy
class simpleLayer:background=[0,0,0,0]content="blank"def getContent(self):return self.contentdef getBackgroud(self):return self.backgrounddef paint(self,painting):self.content=paintingdef setParent(self,p):self.background[3]=pdef fillBackground(self,back):self.background=backdef clone(self):return copy(self)def deep_clone(self):return deepcopy(self)
if  __name__=="__main__":dog_layer=simpleLayer()dog_layer.paint("Dog")dog_layer.fillBackground([0,0,255,0])print ("Original Background:",dog_layer.getBackgroud())print ("Original Painting:",dog_layer.getContent())# 浅复制 / 深复制another_dog_layer=dog_layer.clone()# another_dog_layer = dog_layer.deep_clone()
another_dog_layer.setParent(128)another_dog_layer.paint("Puppy")print ("Original Background:", dog_layer.getBackgroud())print ("Original Painting:", dog_layer.getContent())print ("Copy Background:", another_dog_layer.getBackgroud())print ("Copy Painting:", another_dog_layer.getContent())

#该服务器接受如下格式数据，addr代表地址，content代表接收的信息内容# 模拟服务器接受/发送/显示 信息部分
class Server:content=""def recv(self,info):passdef send(self,info):passdef show(self):pass
class infoServer(Server):def recv(self,info):self.content=inforeturn "recv OK!"def send(self,info):passdef show(self):print ("SHOW:%s"%self.content)class serverProxy:pass
class infoServerProxy(serverProxy):server=""def __init__(self,server):self.server=serverdef recv(self,info):return self.server.recv(info)def show(self):self.server.show()# 代理模式构建部分
class whiteInfoServerProxy(infoServerProxy):white_list=[]def recv(self,info):try:assert type(info)==dictexcept:return "info structure is not correct"addr=info.get("addr",0)if not addr in self.white_list:return "Your address is not in the white list."else:content=info.get("content","")return self.server.recv(content)def addWhite(self,addr):self.white_list.append(addr)def rmvWhite(self,addr):self.white_list.remove(addr)def clearWhite(self):self.white_list=[]if  __name__=="__main__":info_struct = dict()info_struct["addr"] = 10010info_struct["content"] = "Hello World!"# 实例化服务器info_server = infoServer()# 加入代理中info_server_proxy = whiteInfoServerProxy(info_server)# 当没有加入白名单,接受数据print (info_server_proxy.recv(info_struct))info_server_proxy.show()print("----------------")# 加入白名单,接受数据info_server_proxy.addWhite(10010)print (info_server_proxy.recv(info_struct))info_server_proxy.show()

'''
快餐店卖可乐时，可以选择加冰，如果加冰的话，要在原价上加0.3元；
卖牛奶时，可以选择加糖，如果加糖的话，要原价上加0.5元。怎么解决这样的问题？
'''class Beverage():name = ""price = 0.0type = "BEVERAGE"def getPrice(self):return self.pricedef setPrice(self, price):self.price = pricedef getName(self):return self.nameclass coke(Beverage):def __init__(self):self.name = "coke"self.price = 4.0class milk(Beverage):def __init__(self):self.name = "milk"self.price = 5.0# 传统实现方式:
class drinkDecorator():def getName(self):passdef getPrice(self):passclass iceDecorator(drinkDecorator):def __init__(self, beverage):self.beverage = beveragedef getName(self):return self.beverage.getName() + " +ice"def getPrice(self):return self.beverage.getPrice() + 0.3class sugarDecorator(drinkDecorator):def __init__(self, beverage):self.beverage = beveragedef getName(self):return self.beverage.getName() + " +sugar"def getPrice(self):return self.beverage.getPrice() + 0.5if  __name__=="__main__":coke_cola=coke()print ("Name:%s"%coke_cola.getName())print ("Price:%s"%coke_cola.getPrice())ice_coke=iceDecorator(coke_cola)print ("Name:%s" % ice_coke.getName())print ("Price:%s" % ice_coke.getPrice())

'''
假设某公司A与某公司B需要合作，公司A需要访问公司B的人员信息，但公司A与公司B协议接口不同，该如何处理？
先将公司A和公司B针对各自的人员信息访问系统封装了对象接口。
'''class ACpnStaff:name=""id=""phone=""def __init__(self,id):self.id=iddef getName(self):print ("A protocol getName method...id:%s"%self.id)return self.namedef setName(self,name):print ("A protocol setName method...id:%s"%self.id)self.name=namedef getPhone(self):print ("A protocol getPhone method...id:%s"%self.id)return self.phonedef setPhone(self,phone):print ("A protocol setPhone method...id:%s"%self.id)self.phone=phoneclass BCpnStaff:name=""id=""telephone=""def __init__(self,id):self.id=iddef get_name(self):print ("B protocol get_name method...id:%s"%self.id)return self.namedef set_name(self,name):print ("B protocol set_name method...id:%s"%self.id)self.name=namedef get_telephone(self):print ("B protocol get_telephone method...id:%s"%self.id)return self.telephonedef set_telephone(self,telephone):print ("B protocol get_name method...id:%s"%self.id)self.telephone=telephoneclass CpnStaffAdapter:b_cpn=""def __init__(self,id):self.b_cpn=BCpnStaff(id)def getName(self):return self.b_cpn.get_name()def getPhone(self):return self.b_cpn.get_telephone()def setName(self,name):self.b_cpn.set_name(name)def setPhone(self,phone):self.b_cpn.set_telephone(phone)if __name__=="__main__":acpn_staff=ACpnStaff("123")acpn_staff.setName("X-A")acpn_staff.setPhone("10012345678")print ("A Staff Name:%s"%acpn_staff.getName())print ("A Staff Phone:%s"%acpn_staff.getPhone())bcpn_staff=CpnStaffAdapter("456")bcpn_staff.setName("Y-B")bcpn_staff.setPhone("99987654321")print ("B Staff Name:%s"%bcpn_staff.getName())print ("B Staff Phone:%s"%bcpn_staff.getPhone())

'''假设有一组火警报警系统，由三个子元件构成：一个警报器，一个喷水器，一个自动拨打电话的装置。其抽象如下：
在业务中如果需要将三个部件启动，例如，如果有一个烟雾传感器，检测到了烟雾。在业务环境中需要做如下操作：
'''class AlarmSensor:def run(self):print ("Alarm Ring...")
class WaterSprinker:def run(self):print ("Spray Water...")
class EmergencyDialer:def run(self):print ("Dial 119...")# if __name__=="__main__":
#     alarm_sensor=AlarmSensor()
#     water_sprinker=WaterSprinker()
#     emergency_dialer=EmergencyDialer()
#     alarm_sensor.run()
#     water_sprinker.run()
#     emergency_dialer.run()'''
如果在多个业务场景中需要启动三个部件，怎么办？Ctrl+C加上Ctrl+V么？
当然可以这样，但作为码农的基本修养之一，减少重复代码是应该会被很轻易想到的方法。
这样，需要将其进行封装，在设计模式中，被封装成的新对象，叫做门面。门面构建如下：
'''
class EmergencyFacade:def __init__(self):self.alarm_sensor=AlarmSensor()self.water_sprinker=WaterSprinker()self.emergency_dialer=EmergencyDialer()def runAll(self):self.alarm_sensor.run()self.water_sprinker.run()self.emergency_dialer.run()if __name__=="__main__":emergency_facade=EmergencyFacade()emergency_facade.runAll()

'''
每一个公司都有自己的组织结构，越是大型的企业，其组织结构就会越复杂。
大多数情况下，公司喜欢用“树形”结构来组织复杂的公司人事关系和公司间的结构关系。
一般情况下，根结点代表公司的最高行政权利单位，分支节点表示一个个部门，而叶子结点则会用来代表每一个员工。
每一个结点的子树，表示该结点代表的部门所管理的单位。
假设一个具有HR部门，财务部门和研发部门，同时在全国有分支公司的总公司，其公司结构，
可以表示成如下逻辑：'''class Company:name = ''def __init__(self, name):self.name = namedef add(self, company):passdef remove(self, company):passdef display(self, depth):passdef listDuty(self):passclass ConcreteCompany(Company):childrenCompany = Nonedef __init__(self, name):Company.__init__(self,name)self.childrenCompany = []def add(self, company):self.childrenCompany.append(company)def remove(self, company):self.childrenCompany.remove(company)def display(self, depth):print('-'*depth + self.name)for component in self.childrenCompany:component.display(depth+1)def listDuty(self):for component in self.childrenCompany:component.listDuty()
class HRDepartment(Company):def __init__(self, name):Company.__init__(self,name)def display(self, depth):print ('-'*depth + self.name)def listDuty(self): #履行职责print ('%s\t Enrolling & Transfering management.' % self.name)class FinanceDepartment(Company):def __init__(self, name):Company.__init__(self,name)def display(self, depth):print ("-" * depth + self.name)def listDuty(self): #履行职责print ('%s\tFinance Management.'%self.name)class RdDepartment(Company):def __init__(self,name):Company.__init__(self,name)def display(self, depth):print ("-"*depth+self.name)def listDuty(self):print ("%s\tResearch & Development."% self.name)if __name__=="__main__":root = ConcreteCompany('HeadQuarter')root.add(HRDepartment('HQ HR'))root.add(FinanceDepartment('HQ Finance'))root.add(RdDepartment("HQ R&D"))comp = ConcreteCompany('East Branch')comp.add(HRDepartment('East.Br HR'))comp.add(FinanceDepartment('East.Br Finance'))comp.add(RdDepartment("East.Br R&D"))root.add(comp)comp1 = ConcreteCompany('Northast Branch')comp1.add(HRDepartment('Northeast.Br HR'))comp1.add(FinanceDepartment('Northeast.Br Finance'))comp1.add(RdDepartment("Northeast.Br R&D"))comp.add(comp1)comp2 = ConcreteCompany('Southeast Branch')comp2.add(HRDepartment('Southeast.Br HR'))comp2.add(FinanceDepartment('Southeast.Br Finance'))comp2.add(RdDepartment("Southeast.Br R&D"))comp.add(comp2)root.display(1)root.listDuty()

class Customer:coffee_factory=""name=""def __init__(self,name,coffee_factory):self.name=nameself.coffee_factory=coffee_factorydef order(self,coffee_name):print ("%s ordered a cup of coffee:%s"%(self.name,coffee_name))return self.coffee_factory.getCoffee(coffee_name)'''
按照一般的处理流程，用户在网上预订咖啡，其代表用户的Customer类中生成一个Coffee类，直到交易流程结束。
整个流程是没有问题的。如果，随着网站用户越来越多，单位时间内购买咖啡的用户也越来越多，并发量越来越大，
对系统资源的消耗也会越来越大，极端情况下，会造成宕机等严重后果。此时，高效利用资源，就显得非常重要了。
简单分析下业务流程，高并发下用户数量增加，而该模型下，每个用户点一杯咖啡，就会产生一个咖啡实例，
如果一种咖啡在该时间内被很多用户点过，那么就会产生很多同样咖啡的实例。
避免重复实例的出现，是节约系统资源的一个突破口。
类似于单例模式，我们这里在咖啡实例化前，增加一个控制实例化的类：咖啡工厂。
'''class CoffeeFactory():coffee_dict = {}def getCoffee(self, name):if self.coffee_dict.__contains__(name) == False:self.coffee_dict[name] = Coffee(name)return self.coffee_dict[name]def getCoffeeCount(self):return len(self.coffee_dict)if __name__=="__main__":coffee_factory=CoffeeFactory()customer_1=Customer("A Client",coffee_factory)customer_2=Customer("B Client",coffee_factory)customer_3=Customer("C Client",coffee_factory)c1_capp=customer_1.order("cappuccino")c1_capp.show()c2_mocha=customer_2.order("mocha")c2_mocha.show()c3_capp=customer_3.order("cappuccino")c3_capp.show()print ("Num of Coffee Instance:%s"%coffee_factory.getCoffeeCount())

'''
在介绍原型模式的一节中，我们举了个图层的例子，这一小节内容，我们同样以类似画图的例子，说明一种结构类设计模式：桥梁模式。
在一个画图程序中，常会见到这样的情况：有一些预设的图形，如矩形、圆形等，还有一个对象-画笔，调节画笔的类型（如画笔还是画刷，
还是毛笔效果等）并设定参数（如颜色、线宽等），选定图形，就可以在画布上画出想要的图形了。要实现以上需求，先从最抽象的元素开始设计，
即形状和画笔（暂时忽略画布，同时忽略画笔参数，只考虑画笔类型）。
'''class Shape():name=""param=""def __init__(self,*param):passdef getName(self):return self.namedef getParam(self):return self.name,self.paramclass Rectangle(Shape):def __init__(self,long,width):super().__init__()self.name="Rectangle"self.param="Long:%s Width:%s"%(long,width)print ("Create a rectangle:%s"%self.param)class Circle(Shape):def __init__(self,radius):super().__init__()self.name="Circle"self.param="Radius:%s"%radiusprint ("Create a circle:%s"%self.param)class Pen():shape=""type=""def __init__(self,shape):self.shape=shapedef draw(self):passclass NormalPen(Pen):def __init__(self,shape):super().__init__(shape)self.type="Normal Line"def draw(self):print ("DRAWING %s:%s----PARAMS:%s"%(self.type,self.shape.getName(),self.shape.getParam()))
class BrushPen(Pen):def __init__(self,shape):super().__init__(shape)self.type="Brush Line"def draw(self):print ("DRAWING %s:%s----PARAMS:%s" % (self.type,self.shape.getName(), self.shape.getParam()))if __name__=="__main__":normal_pen=NormalPen(Rectangle("20cm","10cm"))brush_pen=BrushPen(Circle("15cm"))normal_pen.draw()brush_pen.draw()

'''
假设某司维护着一些客户资料，需要在该司有新产品上市或者举行新活动时通知客户。现通知客户的方式有两种：
短信通知、邮件通知。应如何设计该系统的客户通知部分？
为解决该问题，我们先构造客户类，包括客户常用的联系方式和基本信息，同时也包括要发送的内容。'''class customer:customer_name=""snd_way=""info=""phone=""email=""def setPhone(self,phone):self.phone=phonedef setEmail(self,mail):self.email=maildef getPhone(self):return self.phonedef getEmail(self):return self.emaildef setInfo(self,info):self.info=infodef setName(self,name):self.customer_name=namedef setBrdWay(self,snd_way):self.snd_way=snd_waydef sndMsg(self):self.snd_way.send(self.info)class msgSender:dst_code=""def setCode(self,code):self.dst_code=codedef send(self,info):pass
class emailSender(msgSender):def send(self,info):print ("EMAIL_ADDRESS:%s EMAIL:%s"%(self.dst_code,info))
class textSender(msgSender):def send(self,info):print ("TEXT_CODE:%s EMAIL:%s"%(self.dst_code,info))if  __name__=="__main__":customer_x=customer()customer_x.setName("CUSTOMER_X")customer_x.setPhone("10023456789")customer_x.setEmail("customer_x@xmail.com")customer_x.setInfo("Welcome to our new party!")text_sender=textSender()text_sender.setCode(customer_x.getPhone())customer_x.setBrdWay(text_sender)customer_x.sndMsg()mail_sender=emailSender()mail_sender.setCode(customer_x.getEmail())customer_x.setBrdWay(mail_sender)customer_x.sndMsg()

'''
假设有这么一个请假系统：
员工若想要请3天以内（包括3天的假），只需要直属经理批准就可以了；
如果想请3-7天，不仅需要直属经理批准，部门经理需要最终批准；
如果请假大于7天，不光要前两个经理批准，也需要总经理最终批准。
类似的系统相信大家都遇到过，那么该如何实现呢？首先想到的当然是if…else…，
但一旦遇到需求变动，其臃肿的代码和复杂的耦合缺点都显现出来。
简单分析下需求，“假条”在三个经理间是单向传递关系，像一条链条一样，
因而，我们可以用一条“链”把他们进行有序连接。'''class manager():successor = Nonename = ''def __init__(self, name):self.name = namedef setSuccessor(self, successor):self.successor = successordef handleRequest(self, request):pass
class lineManager(manager):def handleRequest(self, request):if request.requestType == 'DaysOff' and request.number <= 3:print ('%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number))else:print('%s:%s Num:%d Accepted CONTINUE' % (self.name, request.requestContent, request.number))if self.successor != None:self.successor.handleRequest(request)
class departmentManager(manager):def handleRequest(self, request):if request.requestType == 'DaysOff' and request.number <= 7:print ('%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number))else:print ('%s:%s Num:%d Accepted CONTINUE' % (self.name, request.requestContent, request.number))if self.successor != None:self.successor.handleRequest(request)
class generalManager(manager):def handleRequest(self, request):if request.requestType == 'DaysOff':print ('%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number))
class request():requestType = ''requestContent = ''number = 0if  __name__=="__main__":# 实例化 给个层级部门line_manager = lineManager('LINE MANAGER')department_manager = departmentManager('DEPARTMENT MANAGER')general_manager = generalManager('GENERAL MANAGER')# 将各个层级相互嵌套 1 > 2 > 3
    line_manager.setSuccessor(department_manager)department_manager.setSuccessor(general_manager)# 模拟请求(1天假)req = request()req.requestType = 'DaysOff'req.requestContent = 'Ask 1 day off'req.number = 1line_manager.handleRequest(req)print("------------------------------------")# 模拟请求(5天假)req.requestType = 'DaysOff'req.requestContent = 'Ask 5 days off'req.number = 5line_manager.handleRequest(req)print("------------------------------------")# 模拟请求(10天假)req.requestType = 'DaysOff'req.requestContent = 'Ask 10 days off'req.number = 10line_manager.handleRequest(req)

'''
饭店的点餐系统有什么不同嘛？
大伙想想看，在大多数饭店中，当服务员已经接到顾客的点单，录入到系统中后，根据不同的菜品，会有不同的后台反应。
比如，饭店有凉菜间、热菜间、主食间，那当服务员将菜品录入到系统中后，凉菜间会打印出顾客所点的凉菜条目，
热菜间会打印出顾客所点的热菜条目，主食间会打印出主食条目。那这个系统的后台模式该如何设计？
当然，直接在场景代码中加if…else…语句判断是个方法，可这样做又一次加重了系统耦合，
违反了单一职责原则，遇到系统需求变动时，又会轻易违反开闭原则。所以，我们需要重新组织一下结构。
可以将该系统设计成前台服务员系统和后台系统，后台系统进一步细分成主食子系统，凉菜子系统，热菜子系统。后台三个子系统设计如下：
'''class backSys():def cook(self,dish):pass
class mainFoodSys(backSys):def cook(self,dish):print ("MAINFOOD:Cook %s"%dish)
class coolDishSys(backSys):def cook(self,dish):print ("COOLDISH:Cook %s"%dish)
class hotDishSys(backSys):def cook(self,dish):print ("HOTDISH:Cook %s"%dish)class waiterSys():menu_map=dict()commandList=[]def setOrder(self,command):print ("WAITER:Add dish")self.commandList.append(command)def cancelOrder(self,command):print ("WAITER:Cancel order...")self.commandList.remove(command)def notify(self):print ("WAITER:Nofify...")for command in self.commandList:command.execute()class Command():receiver = Nonedef __init__(self, receiver):self.receiver = receiverdef execute(self):pass
class foodCommand(Command):dish=""def __init__(self,receiver,dish):super().__init__(receiver)self.receiver=receiverself.dish=dishdef execute(self):self.receiver.cook(self.dish)class mainFoodCommand(foodCommand):pass
class coolDishCommand(foodCommand):pass
class hotDishCommand(foodCommand):passclass menuAll:menu_map=dict()def loadMenu(self):#加载菜单，这里直接写死self.menu_map["hot"] = ["Yu-Shiang Shredded Pork", "Sauteed Tofu, Home Style", "Sauteed Snow Peas"]self.menu_map["cool"] = ["Cucumber", "Preserved egg"]self.menu_map["main"] = ["Rice", "Pie"]def isHot(self,dish):if dish in self.menu_map["hot"]:return Truereturn Falsedef isCool(self,dish):if dish in self.menu_map["cool"]:return Truereturn Falsedef isMain(self,dish):if dish in self.menu_map["main"]:return Truereturn Falseif  __name__=="__main__":dish_list=["Yu-Shiang Shredded Pork","Sauteed Tofu, Home Style","Cucumber","Rice"]#顾客点的菜waiter_sys=waiterSys()main_food_sys=mainFoodSys()cool_dish_sys=coolDishSys()hot_dish_sys=hotDishSys()menu=menuAll()# 加载菜单
    menu.loadMenu()# 点菜单分拣所点的菜分属哪个档口for dish in dish_list:if menu.isCool(dish):cmd=coolDishCommand(cool_dish_sys,dish)elif menu.isHot(dish):cmd=hotDishCommand(hot_dish_sys,dish)elif menu.isMain(dish):cmd=mainFoodCommand(main_food_sys,dish)else:continuewaiter_sys.setOrder(cmd)waiter_sys.notify()

'''
有一个手机仓储管理系统，使用者有三方：
销售、仓库管理员、采购。需求是：销售一旦达成订单，销售人员会通过系统的销售子系统部分通知仓储子系统，
仓储子系统会将可出仓手机数量减少，同时通知采购管理子系统当前销售订单；仓储子系统的库存到达阈值以下，
会通知销售子系统和采购子系统，并督促采购子系统采购；采购完成后，采购人员会把采购信息填入采购子系统，
采购子系统会通知销售子系统采购完成，并通知仓库子系统增加库存。
从需求描述来看，每个子系统都和其它子系统有所交流，在设计系统时，
如果直接在一个子系统中集成对另两个子系统的操作，一是耦合太大，二是不易扩展。
为解决这类问题，我们需要引入一个新的角色-中介者-来将“网状结构”精简为“星形结构”。
（为充分说明设计模式，某些系统细节暂时不考虑，例如：仓库满了怎么办该怎么设计。类似业务性的内容暂时不考虑）
'''class colleague():mediator = Nonedef __init__(self,mediator):self.mediator = mediatorclass purchaseColleague(colleague):def buyStuff(self,num):print ("PURCHASE:Bought %s"%num)self.mediator.execute("buy",num)def getNotice(self,content):print ("PURCHASE:Get Notice--%s"%content)class warehouseColleague(colleague):total=0threshold=100def setThreshold(self,threshold):self.threshold=thresholddef isEnough(self):if self.total<self.threshold:print ("WAREHOUSE:Warning...Stock is low... ")self.mediator.execute("warning",self.total)return Falseelse:return Truedef inc(self,num):self.total+=numprint ("WAREHOUSE:Increase %s"%num)self.mediator.execute("increase",num)self.isEnough()def dec(self,num):if num>self.total:print ("WAREHOUSE:Error...Stock is not enough")else:self.total-=numprint ("WAREHOUSE:Decrease %s"%num)self.mediator.execute("decrease",num)self.isEnough()class salesColleague(colleague):def sellStuff(self,num):print ("SALES:Sell %s"%num)self.mediator.execute("sell",num)def getNotice(self, content):print ("SALES:Get Notice--%s" % content)class abstractMediator():purchase=""sales=""warehouse=""def setPurchase(self,purchase):self.purchase=purchasedef setWarehouse(self,warehouse):self.warehouse=warehousedef setSales(self,sales):self.sales=salesdef execute(self,content,num):pass
class stockMediator(abstractMediator):def execute(self,content,num):print ("MEDIATOR:Get Info--%s"%content)if  content=="buy":self.warehouse.inc(num)self.sales.getNotice("Bought %s"%num)elif content=="increase":self.sales.getNotice("Inc %s"%num)self.purchase.getNotice("Inc %s"%num)elif content=="decrease":self.sales.getNotice("Dec %s"%num)self.purchase.getNotice("Dec %s"%num)elif content=="warning":self.sales.getNotice("Stock is low.%s Left."%num)self.purchase.getNotice("Stock is low. Please Buy More!!! %s Left"%num)elif content=="sell":self.warehouse.dec(num)self.purchase.getNotice("Sold %s"%num)else:passif  __name__=="__main__":mobile_mediator=stockMediator()#先配置
mobile_purchase=purchaseColleague(mobile_mediator)mobile_warehouse=warehouseColleague(mobile_mediator)mobile_sales=salesColleague(mobile_mediator)mobile_mediator.setPurchase(mobile_purchase)mobile_mediator.setWarehouse(mobile_warehouse)mobile_mediator.setSales(mobile_sales)mobile_warehouse.setThreshold(2000)mobile_purchase.buyStuff(3000)mobile_sales.sellStuff(120)

'''
投资股票是种常见的理财方式，我国股民越来越多，实时查询股票的需求也越来越大。今天，我们通过一个简单的股票查询客户端来认识一种简单的设计模式：模板模式。
根据股票代码来查询股价分为如下几个步骤：登录、设置股票代码、查询、展示。构造如下的虚拟股票查询器：
'''class StockQueryDevice():stock_code="0"stock_price=0.0def login(self,usr,pwd):passdef setCode(self,code):self.stock_code=codedef queryPrice(self):passdef showPrice(self):passdef operateQuery(self,usr,pwd,code):self.login(usr,pwd)self.setCode(code)self.queryPrice()self.showPrice()return Trueclass WebAStockQueryDevice(StockQueryDevice):def login(self,usr,pwd):if usr=="myStockA" and pwd=="myPwdA":print ("Web A:Login OK... user:%s pwd:%s"%(usr,pwd))return Trueelse:print ("Web A:Login ERROR... user:%s pwd:%s"%(usr,pwd))return Falsedef queryPrice(self):print ("Web A Querying...code:%s "%self.stock_code)self.stock_price=20.00def showPrice(self):print ("Web A Stock Price...code:%s price:%s"%(self.stock_code,self.stock_price))
class WebBStockQueryDevice(StockQueryDevice):def login(self,usr,pwd):if usr=="myStockB" and pwd=="myPwdB":print ("Web B:Login OK... user:%s pwd:%s"%(usr,pwd))return Trueelse:print ("Web B:Login ERROR... user:%s pwd:%s"%(usr,pwd))return Falsedef queryPrice(self):print ("Web B Querying...code:%s "%self.stock_code)self.stock_price=30.00def showPrice(self):print ("Web B Stock Price...code:%s price:%s"%(self.stock_code,self.stock_price))def operateQuery(self,usr,pwd,code):if not self.login(usr,pwd):return Falseself.setCode(code)self.queryPrice()self.showPrice()return Trueif  __name__=="__main__":web_a_query_dev=WebAStockQueryDevice()web_a_query_dev.operateQuery("myStockA","myPwdA","12345")

class MyIter(object):def __init__(self, n):self.index = 0self.n = ndef __iter__(self):# 只能打印一遍平方值。解决办法是，在__iter__中不返回实例，而再返回一个对象，写成：# return selfreturn MyIter(self.n)def __next__(self):if self.index < self.n:value = self.index**2self.index += 1return valueelse:raise StopIteration()if __name__=="__main__":x_square=MyIter(10)for x in x_square:print (x)for x in x_square:print (x)'''
这样，在每次迭代时都可以将迭代器“初始化”，就可以多次迭代了。
另外，在python中，使用生成器可以很方便的支持迭代器协议。
生成器通过生成器函数产生，生成器函数可以通过常规的def语句来定义，
但是不用return返回，而是用yield一次返回一个结果，在每个结果之间挂起和继续它们的状态，来自动实现迭代协议。
'''

'''
假设一个药房，有一些大夫，一个药品划价员和一个药房管理员，它们通过一个药房管理系统组织工作流程。
大夫开出药方后，药品划价员确定药品是否正常，价格是否正确；通过后药房管理员进行开药处理。该系统可以如何实现？
最简单的想法，是分别用一个一个if…else…把划价员处理流程和药房管理流程实现，这样做的问题在于，
扩展性不强，而且单一性不强，一旦有新药的加入或者划价流程、开药流程有些变动，会牵扯比较多的改动。
今天介绍一种解决这类问题的模式：访问者模式。
'''# 构造药品类和工作人员类：
class Medicine:name=""price=0.0def __init__(self,name,price):self.name=nameself.price=pricedef getName(self):return self.namedef setName(self,name):self.name=namedef getPrice(self):return self.pricedef setPrice(self,price):self.price=pricedef accept(self,visitor):pass
class Antibiotic(Medicine):def accept(self,visitor):visitor.visit(self)
class Coldrex(Medicine):def accept(self,visitor):visitor.visit(self)# 药品类中有两个子类，抗生素和感冒药；
class Visitor:name=""def setName(self,name):self.name=namedef visit(self,medicine):pass
class Charger(Visitor):def visit(self,medicine):print("CHARGE: %s lists the Medicine %s. Price:%s " % (self.name,medicine.getName(),medicine.getPrice()))
class Pharmacy(Visitor):def visit(self,medicine):print("PHARMACY:%s offers the Medicine %s. Price:%s" % (self.name,medicine.getName(),medicine.getPrice()))'''
作人员分为划价员和药房管理员。
在药品类中，有一个accept方法，其参数是个visitor；而工作人员就是从Visitor类中继承而来的，也就是说，
他们就是Visitor，都包含一个visit方法，其参数又恰是medicine。药品作为处理元素，
依次允许（Accept）Visitor对其进行操作，这就好比是一条流水线上的一个个工人，对产品进行一次次的加工。
整个业务流程还差一步，即药方类的构建（流水线大机器）。
'''class ObjectStructure:pass
class Prescription(ObjectStructure):medicines=[]def addMedicine(self,medicine):self.medicines.append(medicine)def rmvMedicine(self,medicine):self.medicines.append(medicine)def visit(self,visitor):for medc in self.medicines:medc.accept(visitor)# 药方类将待处理药品进行整理，并组织Visitor依次处理。if __name__=="__main__":yinqiao_pill=Coldrex("Yinqiao Pill",2.0)penicillin=Antibiotic("Penicillin",3.0)doctor_prsrp=Prescription()doctor_prsrp.addMedicine(yinqiao_pill)doctor_prsrp.addMedicine(penicillin)charger=Charger()charger.setName("Doctor Strange")pharmacy=Pharmacy()pharmacy.setName("Doctor Wei")doctor_prsrp.visit(charger)doctor_prsrp.visit(pharmacy)

'''
在门面模式中，我们提到过火警报警器。
在当时，我们关注的是通过封装减少代码重复。而今天，我们将从业务流程的实现角度，来再次实现该火警报警器。'''class AlarmSensor:def run(self):print ("Alarm Ring...")
class WaterSprinker:def run(self):print ("Spray Water...")
class EmergencyDialer:def run(self):print ("Dial 119...")class Observer:def update(self):passclass AlarmSensor(Observer):def update(self,action):print ("Alarm Got: %s" % action)self.runAlarm()def runAlarm(self):print ("Alarm Ring...")class WaterSprinker(Observer):def update(self,action):print ("Sprinker Got: %s" % action)self.runSprinker()def runSprinker(self):print ("Spray Water...")class EmergencyDialer(Observer):def update(self,action):print ("Dialer Got: %s"%action)self.runDialer()def runDialer(self):print ("Dial 119...")class Observed:observers=[]action=""def addObserver(self,observer):self.observers.append(observer)def notifyAll(self):for obs in self.observers:obs.update(self.action)
class smokeSensor(Observed):def setAction(self,action):self.action=actiondef isFire(self):return Trueif __name__=="__main__":alarm=AlarmSensor()sprinker=WaterSprinker()dialer=EmergencyDialer()smoke_sensor=smokeSensor()smoke_sensor.addObserver(alarm)smoke_sensor.addObserver(sprinker)smoke_sensor.addObserver(dialer)if smoke_sensor.isFire():smoke_sensor.setAction("On Fire!")smoke_sensor.notifyAll()

'''
要开发一个自动识别谱子的吉他模拟器，达到录入谱即可按照谱发声的效果。除了发声设备外（假设已完成），最重要的就是读谱和译谱能力了。
分析其需求，整个过程大致上分可以分为两部分：
根据规则翻译谱的内容；根据翻译的内容演奏。我们用一个解释器模型来完成这个功能。
'''class PlayContext():play_text = Noneclass Expression():def interpret(self, context):if len(context.play_text) == 0:returnelse:play_segs=context.play_text.split(" ")for play_seg in play_segs:pos=0for ele in play_seg:if ele.isalpha():pos+=1continuebreakplay_chord = play_seg[0:pos]play_value = play_seg[pos:]self.execute(play_chord,play_value)def execute(self,play_key,play_value):passclass NormGuitar(Expression):def execute(self, key, value):print ("Normal Guitar Playing--Chord:%s Play Tune:%s"%(key,value))if __name__=="__main__":context = PlayContext()context.play_text = "C53231323 Em43231323 F43231323 G63231323"guitar=NormGuitar()guitar.interpret(context)

'''
打过游戏的朋友一定知道，大多数游戏都有保存进度的功能，
如果一局游戏下来，忘保存了进度，那么下次只能从上次进度点开始重新打了。
一般情况下，保存进度是要存在可持久化存储器上，本例中先以保存在内存中来模拟实现该场景的情形。
以模拟一个战斗角色为例。首先，创建游戏角色
'''
import randomclass GameCharacter():vitality = 0attack = 0defense = 0def displayState(self):print ('Current Values:')print ('Life:%d' % self.vitality)print ('Attack:%d' % self.attack)print ('Defence:%d' % self.defense)def initState(self,vitality,attack,defense):self.vitality = vitalityself.attack = attackself.defense = defensedef saveState(self):return Memento(self.vitality, self.attack, self.defense)def recoverState(self, memento):self.vitality = memento.vitalityself.attack = memento.attackself.defense = memento.defenseclass FightCharactor(GameCharacter):def fight(self):self.vitality -= random.randint(1,10)class Memento:vitality = 0attack = 0defense = 0def __init__(self, vitality, attack, defense):self.vitality = vitalityself.attack = attackself.defense = defenseif __name__=="__main__":game_chrctr = FightCharactor()game_chrctr.initState(100,79,60)game_chrctr.displayState()memento = game_chrctr.saveState()game_chrctr.fight()game_chrctr.displayState()game_chrctr.recoverState(memento)game_chrctr.displayState()

'''
电梯在我们周边随处可见，电梯的控制逻辑中心是由电梯控制器实现的。电梯的控制逻辑，即使简单点设计，
把状态分成开门状态，停止状态和运行状态，操作分成开门、关门、运行、停止，那流程也是很复杂的。
首先，开门状态不能开门、运行、停止；停止状态不能关门，停止；运行状态不能开门、关门、运行。
要用一个一个if…else…实现，首先代码混乱，不易维护；二是不易扩展。至于各种设计原则什么的……
那该如何实现？在上边的逻辑中，每个操作仅仅是一个操作，状态切换与操作是分离的，
这也造成后来操作和状态“相互配合”的“手忙脚乱”。如果把状态抽象成一个类，
每个状态为一个子类，每个状态实现什么操作，不实现什么操作，仅仅在这个类中具体实现就可以了。
下面我们实现这个逻辑。
先实现抽象的状态类：
'''class LiftState:def open(self):passdef close(self):passdef run(self):passdef stop(self):passclass OpenState(LiftState):def open(self):print ("OPEN:The door is opened...")return selfdef close(self):print ("OPEN:The door start to close...")print ("OPEN:The door is closed")return StopState()def run(self):print ("OPEN:Run Forbidden.")return selfdef stop(self):print ("OPEN:Stop Forbidden.")return self
class RunState(LiftState):def open(self):print ("RUN:Open Forbidden.")return selfdef close(self):print ("RUN:Close Forbidden.")return selfdef run(self):print ("RUN:The lift is running...")return selfdef stop(self):print ("RUN:The lift start to stop...")print ("RUN:The lift stopped...")return StopState()
class StopState(LiftState):def open(self):print ("STOP:The door is opening...")print ("STOP:The door is opened...")return OpenState()def close(self):print ("STOP:Close Forbidden")return selfdef run(self):print ("STOP:The lift start to run...")return RunState()def stop(self):print ("STOP:The lift is stopped.")return selfclass Context:lift_state=""def getState(self):return self.lift_statedef setState(self,lift_state):self.lift_state=lift_statedef open(self):self.setState(self.lift_state.open())def close(self):self.setState(self.lift_state.close())def run(self):self.setState(self.lift_state.run())def stop(self):self.setState(self.lift_state.stop())if __name__=="__main__":ctx = Context()ctx.setState(StopState())ctx.open()ctx.run()ctx.close()ctx.run()ctx.stop()