Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to realize the boast design pattern in Python code. The content of the article is of high quality, so the editor will share it with you for reference. I hope you will have some understanding of the relevant knowledge after reading this article.

I came into contact with the object-oriented language, only on C++ and Python also understand, in order to deepen the understanding of each model, I downloaded a C++ version of the source code, and according to their own understanding while reading this book while practicing C++ source code, while rewriting it into Python code, can be regarded as three birds with one stone.

Because the purpose of this code is to show each design pattern rather than complete a specific complex task, based on C++ version rewriting, the examples are basically the same as "lie design pattern", coupled with limited personal level, so these Python version code is relatively simple, although it can run is true, but there is inevitably bug, and the implementation is not necessarily *, C++ is relatively strong and not enough pythonic. Also ask the master to forgive and correct. However, I try to show more or less something about pythonic in the "code features" section of each pattern, and this "code features" is not just pythonic stuff.

Use Python version 2.6.

The accompanying picture is also extracted from the "lie Design pattern", so it is a C # style UML class diagram, which has been scaled down for easy typesetting.

1. Simple factory model

Model features: the factory produces classes with different functions according to conditions.

Program example: four operation calculators, according to the user's input to generate the corresponding operation class, using this operation class to deal with specific operations.

Features of the code: switch...case... in Candlestick + Branches use dictionaries instead.

Use the exception mechanism to handle the case where the divisor is 0.

Simple factory model class Operation: def GetResult (self): pass class OperationAdd (Operation): def GetResult (self): return self.op1+self.op2 class OperationSub (Operation): def GetResult (self): return self.op1-self.op2 class OperationMul (Operation): def GetResult (self): return self.op1*self.op2 class OperationDiv (Operation): Def GetResult (self): try: result = self.op1/self.op2 return result except: print "error:divided by zero." Return 0 class OperationUndef (Operation): def GetResult (self): print "Undefine operation." Return 0 class OperationFactory: operation = {} operation ["+"] = OperationAdd (); operation ["-"] = OperationSub (); operation ["*"] = OperationMul (); operation ["/"] = OperationDiv () Def createOperation (self Ch): if ch in self.operation: op = self.operation [ch] else: op = OperationUndef () return op if _ _ 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 ()

II. Strategic model

Pattern characteristics: define the algorithm family and encapsulate them separately, which can replace each other without affecting the client.

Program example: mall cashier software, which needs to be charged according to different sales strategies

Code features: different from the same example 1, the dictionary is used here to avoid the trap of bug caused by keywords not in the dictionary.

Policy mode class CashSuper: def AcceptCash (self,money): return 0 class CashNormal (CashSuper): def AcceptCash (self,money): return money class CashRebate (CashSuper): discount = 0 def _ init__ (self,ds): self.discount = ds def AcceptCash (self,money): return money * self.discount class 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 money class CashContext: def _ init__ (self,csuper): self.cs = csuper def GetResult (self Money): return self.cs.AcceptCash (money) if _ _ name__ = "_ _ main__": money = input ("money:") strategy = {} strategy [1] = CashContext (CashNormal ()) strategy [2] = CashContext (CashRebate (300100)) strategy [3] = CashContext (CashReturn (300100) ctype = input ("type: [1] for normal, [2] for 80% discount [3] for 300100.") If ctype in strategy: cc = strategy [ctype] else: print "Undefine type.Use normal mode." Cc = strategy [1] print "you will pay:%d"% (cc.GetResult (money))

Third, decoration mode

Pattern features: dynamically add additional responsibilities to objects

Program example: show the process of wearing clothes one by one.

Code features: none

Decoration mode class Person: def _ init__ (self,tname): self.name = tname def Show (self): print "dressed% s"% (self.name) class Finery (Person): componet = None def _ init__ (self): pass def Decorate (self) Ct): self.componet = ct def Show (self): if (self.roometworthiness none): self.componet.Show () class TShirts (Finery): def _ init__ (self): pass def Show (self): print "BigT-shirt" self.componet.Show () class BigTrouser (Finery): def _ init__ (self) ): pass def Show (self): print "BigTrouser" self.componet.Show () if _ _ name__ = = "_ _ main__": P = Person ("somebody") bt = BigTrouser () ts = TShirts () bt.Decorate (p) ts.Decorate (bt) ts.Show ()

IV. Agency mode

Pattern features: provide a proxy for other objects to control access to this object.

Program example: description of the characteristics of the same pattern.

Code features: none

Agent mode class Interface: def Request (self): return 0 class 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 ()

5. Factory method model

Schema features: define an interface for creating objects and let subclasses decide which class to instantiate. This delays the instantiation of a class to its subclass.

Program example: the basic class Lei Feng class, derived from the student class and volunteer class, by these two subclasses to complete the "learn from Lei Feng" work. The creation of subclasses is completed by the corresponding subclasses of Lei Feng factory.

Code features: none

Factory method mode class LeiFeng: def Sweep (self): print "LeiFeng sweep" class Student (LeiFeng): def Sweep (self): print "Student sweep" class Volenter (LeiFeng): def Sweep (self): print "Volenter sweep" class LeiFengFactory: def CreateLeiFeng (self): temp = LeiFeng () return temp class StudentFactory (LeiFengFactory): Def CreateLeiFeng (self): temp = Student () return temp class VolenterFactory (LeiFengFactory): def CreateLeiFeng (self): temp = Volenter () return temp if _ _ name__ = "_ _ main__": sf = StudentFactory () s=sf.CreateLeiFeng () s.Sweep () sdf = VolenterFactory () sd=sdf.CreateLeiFeng () sd.Sweep ()

VI. Prototype model

Pattern features: specify the types of objects to be created with prototype instances, and create new objects by copying these prototypes.

Program example: generate a new resume from the resume prototype

Features of the code: the Clone () method provided by the resume class Resume is not really Clone, but just adds a reference to the existing object.

The copy method and deepcopy method in the copy module provided by Python for objects have implemented the prototype pattern, but because of the shallow level of the example, there is no difference between the two.

Prototype pattern import copy class WorkExp: place= "" year=0 class Resume: name =''age = 0 def _ init__ (self,n): self.name = 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): # is not actually a "clone" Only return self if _ _ 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

7. Template method model

Pattern features: define an algorithm skeleton in operation and defer some steps to subclasses.

Program example: the same test paper (parent class) is used in the examination, and different students hand in the test paper they fill in (the implementation of the subclass method).

Code features: none

Template method mode 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 ()

8. Appearance mode

Pattern feature: provides a consistent interface for a set of calls.

Program example: the interface combines several calls into two groups, and the user invokes one of them through the interface.

Code features: none

Appearance mode class SubSystemOne: def MethodOne (self): print "SubSysOne" class SubSystemTwo: def MethodTwo (self): print "SubSysTwo" class SubSystemThree: def MethodThree (self): print "SubSysThree" class SubSystemFour: def MethodFour (self): print "SubSysFour" class 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 ()

IX. Builder model

Schema features: separate the construction of a complex object (Director) from its representation (Builder) so that the same construction process can create different representations (ConcreteBuilder).

Program example: "draw" a villain with sound limbs (head, body and legs)

Code features: none

Builder mode class Person: def CreateHead (self): pass def CreateHand (self): pass def CreateBody (self): pass def CreateFoot (self): pass class 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 foot" class 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 foot" class 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 ()

10. Observer model

Pattern features: an one-to-many relationship is defined, which allows multiple objects to monitor a topic object at the same time, and notifies all observers when the state of the subject object changes.

Program example: there are two kinds of employees in the company who are lazy while the boss is away: those who watch NBA and those who watch the stock market, and ask the boss's secretary to inform them to continue the work at hand when the boss shows up.

Program features: none

Observer mode class Observer: def _ init__ (self,strname,strsub): self.name = strname self.sub = strsub def Update (self): pass class StockObserver (Observer): # no need to rewrite _ init__ () def Update (self): print "% slug% s stop watching Stock and go on work!"% (self.name Self.sub.action) class NBAObserver (Observer): def Update (self): print "% sv% s stop watching NBA and go on work!"% (self.name,self.sub.action) class SecretaryBase: def _ _ init__ (self): self.observers = [] def Attach (self) New_observer): pass def Notify (self): pass class 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 ()

11. Abstract factory model

Schema features: provides an interface to create a series of related or interdependent objects without specifying their classes.

Program example: provides support for different database access.

IUser and IDepartment are two different abstract products, both of which have different implementations of Access and SQL Server; IFactory is an abstract factory that generates IUser and IDepartment, generating concrete objects (CAccessUser and CAccessDepartment, or CSqlUser and CSqlDepartment) based on the concrete implementation (AccessFactory and SqlFactory).

Code features: none

Abstract factory pattern class IUser: def GetUser (self): pass def InsertUser (self): pass class IDepartment: def GetDepartment (self): pass def InsertDepartment (self): pass class CAccessUser (IUser): def GetUser (self): print "Access GetUser" def InsertUser (self): print "Access InsertUser" class CAccessDepartment (IDepartment) Def GetDepartment (self): print "Access GetDepartment" def InsertDepartment (self): print "Access InsertDepartment" class CSqlUser (IUser): def GetUser (self): print "Sql GetUser" def InsertUser (self): print "Sql InsertUser" class CSqlDepartment (IDepartment): def GetDepartment (self): print "Sql GetDepartment" def InsertDepartment (self): Print "Sql InsertDepartment" class IFactory: def CreateUser (self): pass def CreateDepartment (self): pass class AccessFactory (IFactory): def CreateUser (self): temp=CAccessUser () return temp def CreateDepartment (self): temp= CAccessDepartment () return temp class SqlFactory (IFactory): def CreateUser (self): temp= CSqlUser ( ) return temp def CreateDepartment (self): temp = CSqlDepartment () return temp if _ _ name__ = = "_ main__": factory = SqlFactory () user=factory.CreateUser () depart=factory.CreateDepartment () user.GetUser () depart.GetDepartment ()

12. State mode

Pattern features: an object is allowed to change its behavior when its internal state changes, and the object seems to have changed its class.

Program example: describes the working state of a programmer, which changes when the state needs to be changed, and the methods are implemented differently in different states.

Code features: none

State mode class State: def WirteProgram (self): pass class 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.hour

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.