来源：http://www.cnblogs.com/wuyuegb2312/archive/2013/04/09/3008320.html
一、简单工厂模式
模式特点：工厂根据条件产生不同功能的类。
程序实例：四则运算计算器，根据用户的输入产生相应的运算类，用这个运算类处理具体的运算。
代码特点：C/C++中的switch...case...分支使用字典的方式代替。
使用异常机制对除数为0的情况进行处理。
class Operation(object):
def get_result(self):
pass
class Add(Operation):
def get_result(self):
return self.op1+self.op2
class Sub(Operation):
def get_result(self):
return self.op1 - self.op2
class Mul(Operation):
def get_result(self):
return self.op1 * self.op2
class Div(Operation):
def get_result(self):
return self.op1 / self.op2
class Undef(Operation):
def get_result(self):
print "no define operator"
class Factory(object):
operator = dict()
operator["+"] = Add()
operator["-"] = Sub()
operator["*"] = Mul()
operator["/"] = Div()
def create_operator(self, ch):
op = self.operator[ch] if ch in self.operator else Undef()
return op
def main():
print "*" * 30
op = raw_input("operator:")
opa = input("a:")
opb = input("b:")
factory = Factory()
cal = factory.create_operator(op)
cal.op1 = opa
cal.op2 = opb
print cal.get_result()
if __name__ == "__main__":
while 1:
main()
pass
二、策略模式
模式特点：定义算法家族并且分别封装，它们之间可以相互替换而不影响客户端。
程序实例：商场收银软件，需要根据不同的销售策略方式进行收费
代码特点：不同于同例1，这里使用字典是为了避免关键字不在字典导致bug的陷阱。
# _*_ coding:utf-8 _*_
import os
class CashSuper(object):
def accept_cash(self, money):
return 0
class CashNormal(CashSuper):
def accept_cash(self, money):
return money
class CashRebate(CashSuper):
discount = 0
def __init__(self, ds):
self.discount = ds
def accept_cash(self, money):
return money * self.discount
class CashReturn(CashSuper):
total = 0
ret = 0
def __init__(self, total, ret):
self.total = total
self.ret = ret
def accept_cash(self, money):
if money >= self.total:
return money - self.ret
else:
return money
class CashContext:
def __init__(self, child_class):
self.cs = child_class
def get_result(self, money):
return self.cs.accept_cash(money)
def main():
print "*" * 30
money = input("money:")
strategy = dict()
strategy[1] = CashContext(CashNormal())
strategy[2] = CashContext(CashRebate(0.8))
strategy[3] = CashContext(CashReturn(300, 100))
ctype = input("type:[1]for normal,[2]for 80% discount [3]for 300 -100.")
if ctype in strategy:
cc = strategy[ctype]
else:
print "no define type. Use normal mode."
cc = strategy[1]
print "you will pay:%d" % (cc.GetResult(money))
if __name__ == "__main__":
main()
三、装饰模式
模式特点：动态地为对象增加额外的职责
程序实例：展示一个人一件一件穿衣服的过程。
代码特点：无
class Person(object):
def __init__(self, name):
self.name = name
def show(self):
print "dressed %s" % self.name
class Finery(Person):
component = None
def __init__(self):
super(Finery, self).__init__("")
pass
def decorate(self, ct):
self.component = ct
def show(self):
if self.component is not None:
self.component.show()
class TShirts(Finery):
def __init__(self):
super(TShirts, self).__init__()
pass
def show(self):
print "Big T-shirt "
self.component.show()
class BigTrouser(Finery):
def __init__(self):
super(BigTrouser, self).__init__()
pass
def show(self):
print "Big Trouser "
self.component.show()
def main():
p = Person("somebody")
bt = BigTrouser()
ts = TShirts()
bt.decorate(p)
ts.decorate(bt)
ts.show()
if __name__ == "__main__":
main()
四、代理模式
模式特点：为其他对象提供一种代理以控制对这个对象的访问。
程序实例：同模式特点描述。
代码特点：无
class Interface(object):
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()
def main():
p = Proxy()
p.request()
if __name__ == "__main__":
main()
五、工厂方法模式
模式特点：定义一个用于创建对象的接口，让子类决定实例化哪一个类。这使得一个类的实例化延迟到其子类。
程序实例：基类雷锋类，派生出学生类和志愿者类，由这两种子类完成“学雷锋”工作。子类的创建由雷锋工厂的对应的子类完成。
代码特点：无
class LeiFeng(object):
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
def main():
sf = StudentFactory()
s = sf.CreateLeiFeng()
s.Sweep()
sdf = VolenterFactory()
sd = sdf.CreateLeiFeng()
sd.Sweep()
if __name__ == "__main__":
main()
六、原型模式
模式特点：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
程序实例：从简历原型，生成新的简历
代码特点：简历类Resume提供的Clone()方法其实并不是真正的Clone，只是为已存在对象增加了一次引用。
Python为对象提供的copy模块中的copy方法和deepcopy方法已经实现了原型模式，但由于例子的层次较浅，二者看不出区别。
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):
#实际不是“克隆”，只是返回了自身
return self
def 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()
if __name__ == "__main__":
main()
七、模板方法模式
模式特点：定义一个操作中的算法骨架，将一些步骤延迟至子类中。
程序实例：考试时使用同一种考卷（父类），不同学生上交自己填写的试卷（子类方法的实现）
代码特点：无
