《大话设计模式》Python版代码实现.doc

大话设计模式Python版代码实现上一周把大话设计模式看完了，对面向对象技术有了新的理解，对于一个在C下写代码比较多、偶尔会用到一些脚本语言写脚本的人来说，很是开阔眼界。大话设计模式的代码使用C#写成的，而在本人接触到的面向对象语言中，只对C+和Python还算了解，为了加深对各个模式的理解，我在网上下载了一个C+版的源代码，并根据自己的理解边读这本书边动手实践C+源代码，同时将其改写成了Python代码，算是一箭三雕吧。由于这些代码的目的是展示各个设计模式而非完成一个具体的复杂任务，基于C+版本改写，例子的取材也和大话设计模式基本相同，再加上个人水平有限，因此这些Python版代码写的比较简单，虽然能跑起来是不假，不过难免有bug，而且实现也不一定最优，C+的味道比较浓而不够pythonic，还请高手包容指正。不过我还是尽量把或多或少有些pythonic的东西放在每个模式的“代码特点”部分进行展示，而这个“代码特点”里也不仅仅是pythonic的东西。使用Python版本为2.6。配图同样摘自大话设计模式，因此是C#风格的UML类图，为了便于排版已经缩小了。一、简单工厂模式模式特点：工厂根据条件产生不同功能的类。程序实例：四则运算计算器，根据用户的输入产生相应的运算类，用这个运算类处理具体的运算。代码特点：C/C+中的switch.case.分支使用字典的方式代替。使用异常机制对除数为0的情况进行处理。简单工厂模式class Operation: def GetResult(self): passclass OperationAdd(Operation): def GetResult(self): return self.op1+self.op2class OperationSub(Operation): def GetResult(self): return self.op1-self.op2class OperationMul(Operation): def GetResult(self): return self.op1*self.op2class OperationDiv(Operation): def GetResult(self): try: result = self.op1/self.op2 return result except: print error:divided by zero. return 0class OperationUndef(Operation): def GetResult(self): print Undefine operation. return 0class OperationFactory: operation = operation+ = OperationAdd(); operation- = OperationSub(); operation* = OperationMul(); operation/ = OperationDiv(); def createOperation(self,ch): if ch in self.operation: op = self.operationch else: op = OperationUndef() return opif _name_ = _main_: op = raw_input(operator: ) opa = input(a: ) opb = input(b: ) factory = OperationFactory() cal = factory.createOperation(op) cal.op1 = opa cal.op2 = opb print cal.GetResult()二、策略模式模式特点：定义算法家族并且分别封装，它们之间可以相互替换而不影响客户端。程序实例：商场收银软件，需要根据不同的销售策略方式进行收费代码特点：不同于同例1，这里使用字典是为了避免关键字不在字典导致bug的陷阱。策略模式class CashSuper: def AcceptCash(self,money): return 0class CashNormal(CashSuper): def AcceptCash(self,money): return moneyclass CashRebate(CashSuper): discount = 0 def _init_(self,ds): self.discount = ds def AcceptCash(self,money): return money * self.discountclass CashReturn(CashSuper): total = 0; ret = 0; def _init_(self,t,r): self.total = t self.ret = r def AcceptCash(self,money): if (money=self.total): return money - self.ret else: return moneyclass CashContext: def _init_(self,csuper): self.cs = csuper def GetResult(self,money): return self.cs.AcceptCash(money)if _name_ = _main_: money = input(money:) strategy = strategy1 = CashContext(CashNormal() strategy2 = CashContext(CashRebate(0.8) strategy3 = CashContext(CashReturn(300,100) ctype = input(type:1for normal,2for 80% discount 3for 300 -100.) if ctype in strategy: cc = strategyctype else: print Undefine type.Use normal mode. cc = strategy1 print you will pay:%d %(cc.GetResult(money)三、装饰模式模式特点：动态地为对象增加额外的职责程序实例：展示一个人一件一件穿衣服的过程。代码特点：无装饰模式class Person: def _init_(self,tname): = tname def Show(self): print dressed %s %()class Finery(Person): componet = None def _init_(self): pass def Decorate(self,ct): ponet = ct def Show(self): if(ponet!=None): ponet.Show()class TShirts(Finery): def _init_(self): pass def Show(self): print Big T-shirt ponet.Show()class BigTrouser(Finery): def _init_(self): pass def Show(self): print Big Trouser ponet.Show()if _name_ = _main_: p = Person(somebody) bt = BigTrouser() ts = TShirts() bt.Decorate(p) ts.Decorate(bt) ts.Show()四、代理模式模式特点：为其他对象提供一种代理以控制对这个对象的访问。程序实例：同模式特点描述。代码特点：无代理模式class Interface : def Request(self): return 0class RealSubject(Interface): def Request(self): print Real request.class Proxy(Interface): def Request(self): self.real = RealSubject() self.real.Request()if _name_ = _main_: p = Proxy() p.Request()五、工厂方法模式模式特点：定义一个用于创建对象的接口，让子类决定实例化哪一个类。这使得一个类的实例化延迟到其子类。程序实例：基类雷锋类，派生出学生类和志愿者类，由这两种子类完成“学雷锋”工作。子类的创建由雷锋工厂的对应的子类完成。代码特点：无工厂方法模式class LeiFeng: def Sweep(self): print LeiFeng sweepclass Student(LeiFeng): def Sweep(self): print Student sweepclass Volenter(LeiFeng): def Sweep(self): print Volenter sweepclass LeiFengFactory: def CreateLeiFeng(self): temp = LeiFeng() return tempclass StudentFactory(LeiFengFactory): def CreateLeiFeng(self): temp = Student() return tempclass VolenterFactory(LeiFengFactory): def CreateLeiFeng(self): temp = Volenter() return tempif _name_ = _main_: sf = StudentFactory() s=sf.CreateLeiFeng() s.Sweep() sdf = VolenterFactory() sd=sdf.CreateLeiFeng() sd.Sweep()六、原型模式模式特点：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。程序实例：从简历原型，生成新的简历代码特点：简历类Resume提供的Clone()方法其实并不是真正的Clone，只是为已存在对象增加了一次引用。Python为对象提供的copy模块中的copy方法和deepcopy方法已经实现了原型模式，但由于例子的层次较浅，二者看不出区别。原型模式import copyclass WorkExp: place= year=0class Resume: name = age = 0 def _init_(self,n): = n def SetAge(self,a): self.age = a def SetWorkExp(self,p,y): self.place = p self.year = y def Display(self): print self.age print self.place print self.year def Clone(self): #实际不是“克隆”，只是返回了自身 return selfif _name_ = _main_: a = Resume(a) b = a.Clone() c = copy.copy(a) d = copy.deepcopy(a) a.SetAge(7) b.SetAge(12) c.SetAge(15) d.SetAge(18) a.SetWorkExp(PrimarySchool,1996) b.SetWorkExp(MidSchool,2001) c.SetWorkExp(HighSchool,2004) d.SetWorkExp(University,2007) a.Display() b.Display() c.Display() d.Display()七、模板方法模式模式特点：定义一个操作中的算法骨架，将一些步骤延迟至子类中。程序实例：考试时使用同一种考卷（父类），不同学生上交自己填写的试卷（子类方法的实现）代码特点：无模板方法模式class TestPaper: def TestQuestion1(self): print Test1:A. B. C. D. print (%s) %self.Answer1() def TestQuestion2(self): print Test1:A. B. C. D. print (%s) %self.Answer2() def Answer1(self): return def Answer2(self): return class TestPaperA(TestPaper): def Answer1(self): return B def Answer2(self): return C;class TestPaperB(TestPaper): def Answer1(self): return D def Answer2(self): return D;if _name_ = _main_: s1 = TestPaperA() s2 = TestPaperB() print student 1 s1.TestQuestion1() s1.TestQuestion2() print student 2 s2.TestQuestion1() s2.TestQuestion2()八、外观模式模式特点：为一组调用提供一致的接口。程序实例：接口将几种调用分别组合成为两组，用户通过接口调用其中的一组。代码特点：无外观模式class SubSystemOne: def MethodOne(self): print SubSysOneclass SubSystemTwo: def MethodTwo(self): print SubSysTwoclass SubSystemThree: def MethodThree(self): print SubSysThreeclass SubSystemFour: def MethodFour(self): print SubSysFourclass Facade: def _init_(self): self.one = SubSystemOne() self.two = SubSystemTwo() self.three = SubSystemThree() self.four = SubSystemFour() def MethodA(self): print MethodA self.one.MethodOne() self.two.MethodTwo() self.four.MethodFour() def MethodB(self): print MethodB self.two.MethodTwo() self.three.MethodThree()if _name_ = _main_: facade = Facade() facade.MethodA() facade.MethodB()九、建造者模式模式特点：将一个复杂对象的构建(Director)与它的表示(Builder)分离，使得同样的构建过程可以创建不同的表示(ConcreteBuilder)。程序实例：“画”出一个四肢健全（头身手腿）的小人代码特点：无建造者模式class Person: def CreateHead(self): pass def CreateHand(self): pass def CreateBody(self): pass def CreateFoot(self): passclass ThinPerson(Person): def CreateHead(self): print thin head def CreateHand(self): print thin hand def CreateBody(self): print thin body def CreateFoot(self): print thin footclass ThickPerson(Person): def CreateHead(self): print thick head def CreateHand(self): print thick hand def CreateBody(self): print thick body def CreateFoot(self): print thick footclass Director: def _init_(self,temp): self.p = temp def Create(self): self.p.CreateHead() self.p.CreateBody() self.p.CreateHand() self.p.CreateFoot()if _name_ = _main_: p = ThickPerson() d = Director(p) d.Create()十、观察者模式模式特点：定义了一种一对多的关系，让多个观察对象同时监听一个主题对象，当主题对象状态发生变化时会通知所有观察者。程序实例：公司里有两种上班时趁老板不在时偷懒的员工：看NBA的和看股票行情的，并且事先让老板秘书当老板出现时通知他们继续做手头上的工作。程序特点：无观察者模式class Observer: def _init_(self,strname,strsub): = strname self.sub = strsub def Update(self): passclass StockObserver(Observer): #no need to rewrite _init_() def Update(self): print %s:%s,stop watching Stock and go on work! %(,self.sub.action)class NBAObserver(Observer): def Update(self): print %s:%s,stop watching NBA and go on work! %(,self.sub.action)class SecretaryBase: def _init_(self): self.observers = def Attach(self,new_observer): pass def Notify(self): passclass Secretary(SecretaryBase): def Attach(self,new_observer): self.observers.append(new_observer) def Notify(self): for p in self.observers: p.Update()if _name_ = _main_: p = Secretary() s1 = StockObserver(xh,p) s2 = NBAObserver(wyt,p) p.Attach(s1); p.Attach(s2); p.action = WARNING:BOSS ; p.Notify()十一、抽象工厂模式模式特点：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类。程序实例：提供对不同的数据库访问的支持。IUser和IDepartment是两种不同的抽象产品，它们都有Access和SQL Server这两种不同的实现；IFactory是产生IUser和IDepartment的抽象工厂，根据具体实现（AccessFactory和SqlFactory）产生对应的具体的对象（CAccessUser与CAccessDepartment，或者CSqlUser与CSqlDepartment）。代码特点：无抽象工厂模式class IUser: def GetUser(self): pass def InsertUser(self): passclass IDepartment: def GetDepartment(self): pass def InsertDepartment(self): passclass CAccessUser(IUser): def GetUser(self): print Access GetUser def InsertUser(self): print Access InsertUserclass CAccessDepartment(IDepartment): def GetDepartment(self): print Access GetDepartment def InsertDepartment(self): print Access InsertDepartmentclass CSqlUser(IUser): def GetUser(self): print Sql GetUser def InsertUser(self): print Sql InsertUserclass CSqlDepartment(IDepartment): def GetDepartment(self): print Sql GetDepartment def InsertDepartment(self): print Sql InsertDepartmentclass IFactory: def CreateUser(self): pass def CreateDepartment(self): passclass AccessFactory(IFactory): def CreateUser(self): temp=CAccessUser() return temp def CreateDepartment(self): temp = CAccessDepartment() return tempclass SqlFactory(IFactory): def CreateUser(self): temp = CSqlUser() return temp def CreateDepartment(self): temp = CSqlDepartment() return tempif _name_ = _main_: factory = SqlFactory() user=factory.CreateUser() depart=factory.CreateDepartment() user.GetUser() depart.GetDepartment()十二、状态模式模式特点：当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。程序实例：描述一个程序员的工作状态，当需要改变状态时发生改变，不同状态下的方法实现不同代码特点：无状态模式class State: def WirteProgram(self): passclass Work: def _init_(self): self.hour = 9 self.current = ForenoonState() def SetState(self,temp): self.current = temp def WriteProgram(self): self.current.WriteProgram(self)class NoonState(State): def WriteProgram(self,w): print noon working if (w.hour13): print fun. else: print need to rest.class ForenoonState(State): def WriteProgram(self,w): if (w.hour12): print morning working print energetic else: w.SetState(NoonState() w.WriteProgram()if _name_ = _main_: mywork = Work() mywork.hour = 9 mywork.WriteProgram() mywork.hour =14 mywork.WriteProgram()十三、适配器模式模式特点：将一个类的接口转换成为客户希望的另外一个接口。程序实例：用户通过适配器使用一个类的方法。代码特点：无适配器模式class Target: def Request(): print common request.class Adaptee(Target): def SpecificRequest(self): print specific request.class Adapter(Target): def _init_(self,ada): self.adaptee = ada def Request(self): self.adaptee.SpecificRequest()if _name_ = _main_: adaptee = Adaptee() adapter = Adapter(adaptee) adapter.Request()十四、备忘录模式模式特点：在不破坏封装性的前提下捕获一个对象的内部状态，并在该对象之外保存这个状态，以后可以将对象恢复到这个状态。程序实例：将Originator对象的状态封装成Memo对象保存在Caretaker内代码特点：无备忘录模式class Originator: def _init_(self): self.state = def Show(self): print self.state def CreateMemo(self): return Memo(self.state) def SetMemo(self,memo): self.state = memo.stateclass Memo: state= def _init_(self,ts): self.state = tsclass Caretaker: memo = if _name_ = _main_: on = Originator() on.state = on on.Show() c = Caretaker() c.memo=on.CreateMemo() on.state=off on.Show() on.SetMemo(c.memo) on.Show()十五、组合模式模式特点：将对象组合成成树形结构以表示“部分-整体”的层次结构程序实例：公司人员的组织结构代码特点：无组合模式class Component: def _init_(self,strName): self.m_strName = strName def Add(self,com): pass def Display(self,nDepth): passclass Leaf(Component): def Add(self,com): print leaf cant add def Display(self,nDepth): strtemp = for i in range(nDepth): strtemp=strtemp+- strtemp=strtemp+self.m_strName print strtempclass Composite(Component): def _init_(self,strName): self.m_strName = strName self.c = def Add(self,com): self.c.append(com) def Display(self,nDepth): strtemp= for i in range(nDepth): strtemp=strtemp+- strtemp=strtemp+self.m_strName print strtemp for com in self.c: com.Display(nDepth+2)if _name_ = _main_: p = Composite(Wong) p.Add(Leaf(Lee) p.Add(Leaf(Zhao) p1 = Composite(Wu) p1.Add(Leaf(San) p.Add(p1) p.Display(1);十六、迭代器模式模式特点：提供方法顺序访问一个聚合对象中各元素，而又不暴露该对象的内部表示说明：这个模式没有写代码实现，原因是使用Python的列表和for . in list就能够完成不同类型对象聚合的迭代功能了。十七、单例模式模式特点：保证类仅有一个实例，并提供一个访问它的全局访问点。说明： 为了实现单例模式费了不少工夫，后来查到一篇博文对此有很详细的介绍，而且实现方式也很丰富，通过对代码的学习可以了解更多Python的用法。以下的代码出自GhostFromHeaven的专栏，地址：/ghostfromheaven/article/details/7671853。不过正如其作者在Python单例模式终极版所说：我要问的是，Python真的需要单例模式吗？我指像其他编程语言中的单例模式。答案是：不需要！因为，Python有模块（module），最pythonic的单例典范。模块在在一个应用程序中只有一份，它本身就是单例的，将你所需要的属性和方法，直接暴露在模块中变成模块的全局变量和方法即可！单例模式（四种方法）#-*- encoding=utf-8 -*-print -方法1-#方法1,实现_new_方法#并在将一个类的实例绑定到类变量_instance上,#如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回#如果cls._instance不为None,直接返回cls._instanceclass 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._instanceclass MyClass(Singleton): a = 1one = MyClass()two = MyClass()two.a = 3print one.a#3#one和two完全相同,可以用id(), =, is检测print id(one)#29097904print id(two)#29097904print one = two#Trueprint one is two#Trueprint -方法2-#方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)#同一个类的所有实例天然拥有相同的行为(方法),#只需要保证同一个类的所有实例具有相同的状态(属性)即可#所有实例共享属性的最简单最直接的方法就是_dict_属性指向(引用)同一个字典(dict)#可参看:/recipes/66531/class Borg(object): _state = def _new_(cls, *args, *kw): ob = super(Borg, cls)._new_(cls, *args, *kw) ob._dict_ = cls._state return obclass MyClass2(Borg): a = 1one = MyClass2()two = MyClass2()#one和two是两个不同的对象,id, =, is对比结果可看出two.a = 3print one.a#3print id(one)#28873680print id(two)#28873712print one = two#Falseprint one is two#False#但是one和two具有相同的（同一个_dict_属性）,见:print id(one._dict_)#30104000print id(two._dict_)#30104000print -方法3-#方法3:本质上是方法1的升级（或者说高级）版#使用_metaclass_（元类）的高级python用法class Singleton2(type): def _init_(cls, name, bases, dict): super(Singleton2, cls)._init_(name, bases, dict) cls._inst