来源：

一、简单工厂模式

模式特点：工厂根据条件产生不同功能的类。

程序实例：四则运算计算器，根据用户的输入产生相应的运算类，用这个运算类处理具体的运算。

代码特点：C/C++中的switch...case...分支使用字典的方式代替。

　　　　　使用异常机制对除数为0的情况进行处理。

class Operation(object):    def get_result(self):        passclass Add(Operation):    def get_result(self):        return self.op1+self.op2class Sub(Operation):    def get_result(self):        return self.op1 - self.op2class Mul(Operation):    def get_result(self):        return self.op1 * self.op2class Div(Operation):    def get_result(self):        return self.op1 / self.op2class 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 opdef 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 osclass CashSuper(object):    def accept_cash(self, money):        return 0class CashNormal(CashSuper):    def accept_cash(self, money):        return moneyclass CashRebate(CashSuper):    discount = 0    def __init__(self, ds):        self.discount = ds    def accept_cash(self, money):        return money * self.discountclass 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 moneyclass 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.nameclass 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 0class 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 tempclass StudentFactory(LeiFengFactory):    def CreateLeiFeng(self):        temp = Student()        return tempclass VolenterFactory(LeiFengFactory):    def CreateLeiFeng(self):        temp = Volenter()        return tempdef 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 copyclass WorkExp:    place=""    year=0class 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()

七、模板方法模式

 

模式特点：定义一个操作中的算法骨架，将一些步骤延迟至子类中。

程序实例：考试时使用同一种考卷（父类），不同学生上交自己填写的试卷（子类方法的实现）

代码特点：无