Contents
设计模式
介绍
创建型模式
singleton(单件)
意图
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
经典应用
MFC中的App类，一般程序中用到的全局变量。
实现代码
1 class Singleton:
2 """ A python singleton """
3
4 class __impl:
5 """ Implementation of the singleton interface """
6
7 def spam(self):
8 """ Test method, return singleton id """
9 return id(self)
10
11 # storage for the instance reference
12 __instance = None
13
14 def __init__(self):
15 """ Create singleton instance """
16 # Check whether we already have an instance
17 if Singleton.__instance is None:
18 # Create and remember instance
19 Singleton.__instance = Singleton.__impl()
20
21 # Store instance reference as the only member in the handle
22 self.__dict__['_Singleton__instance'] = Singleton.__instance
23
24 def __getattr__(self, attr):
25 """ Delegate access to implementation """
26 return getattr(self.__instance, attr)
27
28 def __setattr__(self, attr, value):
29 """ Delegate access to implementation """
30 return setattr(self.__instance, attr, value)
31
32
33 # Test it
34 s1 = Singleton()
35 print id(s1), s1.spam()
36
37 s2 = Singleton()
38 print id(s2), s2.spam()
39
40 # Sample output, the second (inner) id is constant:
41 # 8172684 8176268
42 # 8168588 8176268
另一个实现代码
从TaskCoach的代码中摘抄，因此许可证为GPL。 -- QiangningHong
1 class Singleton(type):
2 """Singleton Metaclass"""
3
4 def __init__(cls, name, bases, dic):
5 super(Singleton, cls).__init__(name, bases, dic)
6 cls.instance = None
7
8 def __call__(cls, *args, **kwargs):
9 if cls.instance is None:
10 cls.instance = super(Singleton, cls).__call__(*args, **kwargs)
11 return cls.instance
使用方法:
结构型模式
Proxy（代理）
意图
为其他对象提供一种代理以控制对这个对象的访问。
代码
例子
使用Proxy改变Blue函数：
使用： >>> rgb = RGB( 100, 192, 240 )
>>> rgb.Red()
100
>>> proxy = Proxy( rgb )
>>> proxy.Green()
192
>>> noblue = NoBlueProxy( rgb )
>>> noblue.Green()
192
>>> noblue.Blue()
0
}}} 使用： >>> rgb = RGB( 100, 192, 240 )
>>> rgb.Red()
100
>>> proxy = Proxy( rgb )
>>> proxy.Green()
192
>>> noblue = NoBlueProxy( rgb )
>>> noblue.Green()
192
>>> noblue.Blue()
0
特殊说明
因为在Proxy中没有setattr函数，因此只可以得到rgb中的值，但不能改变，比如可以"r = noblue._RBGred"，但不能写"noblue._RBGred = 255"，如果要想改变RBG中的值，只有在RBG中定义一些函数如"setBlue..."，在noblue中直接调用。
在Proxy中也不能定义setattr，否则在init中会发生死循环。
flyweight
意图
运用共享技术有效地支持大量细粒度的对象。
实现代码
1 #实现过程类似于singleton模式
2
3 import weakref
4 #weekref产生的value不能保持对象存在。当对象不包括weakref在内的引用计数达到0时，对象将被删除。
5
6 class Instrument(object):
7 _InstrumentPool = weakref.WeakValueDictionary()
8
9 def __new__(cls, name):
10 '''Instrument(name)
11 Create a new instrument object, or return an existing one'''
12 obj = Instrument._InstrumentPool.get(name, None)
13
14 if not obj:
15 print "new",name
16 obj = object.__new__(cls)
17 Instrument._InstrumentPool[name] = obj
18
19 return obj
20
21 def __init__(self, name):
22 '''Complete object construction'''
23 self.name = name
24 print "New instrument @%04x, %s" % (id(self), name)
25
26 # ... connect instrument to datasource ...
27
28 #测试
29 import unittest
30
31 class InstrumentTests(unittest.TestCase):
32 def testInstrument(self):
33 ibm1 = Instrument("IBM")
34 ms = Instrument("MS")
35 ibm2 = Instrument("IBM")
36 self.assertEquals(id(ibm1), id(ibm2))
37 self.assertNotEquals(id(ibm1), id(ms))
38
39 self.assertEquals(2, len(Instrument._InstrumentPool),
40 "Total instruments allocated")
41
42 # This bit assumes CPython memory allocation:
43 del(ibm1)
44 del(ibm2)
45 # 每一次调用Instrument，因其函数__new__中的Instrument._InstrumentPool[name]是weakref，只有obj = object.__new__(cls)引用一次。所以del(ibm1)和del(imb2)后引用计数达到0，对象被清理。
46 self.assertEquals(1, len(Instrument._InstrumentPool),
47 "Total instruments allocated")
48
49
50 if __name__=='__main__':
51 unittest.main()
行为模式
Chain of Responsibility（职责链）
意图
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
说明
用一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合,唯一共同点是在他们之间传递request. 也就是说，来了一个请求，A类先处理，如果没有处理，就传递到B类处理，如果没有处理，就传递到C类处理，就这样象一个链条(chain)一样传递下去。 例如，窗口UI对消息的处理：
代码实现
模拟UI对消息的处理
1 class Event:
2 def __init__( self, name ):
3 self.name = name
4
5 class Widget:
6 def __init__( self, parent = None ):
7 self.__parent = parent
8 def Handle( self, event ):
9 handler = 'Handle_' + event.name
10 if hasattr( self, handler ):
11 method = getattr( self, handler )
12 method( event )
13 elif self.__parent:
14 self.__parent.Handle( event )
15 elif hasattr( self, 'HandleDefault' ):
16 self.HandleDefault( event )
使用： 当用一个event被Handle，将调用Handle_"event.name"，如果没有此函数就调用parent来处理此event，如果还没有被处理，就试着交给HandleDefault（）。 例如：
Observer(观察者）
意图
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
经典应用
MFC中document类对所有view的更新，ddx/ddv对窗口上控件的更新。
代码实现
1 class Subject:
2 def __init__(self):
3 self._observers = []
4
5 def attach(self, observer):
6 if not observer in self._observers:
7 self._observers.append(observer)
8
9 def detach(self, observer):
10 try:
11 self._observers.remove(observer)
12 except ValueError:
13 pass
14
15 def notify(self, modifier=None):
16 for observer in self._observers:
17 if modifier != observer:
18 observer.update(self)
例子，用法
1 # Example usage
2 class Data(Subject):
3 def __init__(self, name=''):
4 Subject.__init__(self)
5 self.name = name
6 self.data = 0
7
8 def setData(self, data):
9 self.data = data
10 self.notify()
11
12 def getData(self):
13 return self.data
14
15
16 class HexViewer:
17 def update(self, subject):
18 print 'HexViewer: Subject %s has data 0x%x' % (subject.name, subject.getData())
19
20
21 class DecimalViewer:
22 def update(self, subject):
23 print 'DecimalViewer: Subject %s has data %d' % (subject.name, subject.getData())
24
25
26 # Example usage...
27 def main():
28 data1 = Data('Data 1')
29 data2 = Data('Data 2')
30 view1 = DecimalViewer()
31 view2 = HexViewer()
32 data1.attach(view1)
33 data1.attach(view2)
34 data2.attach(view2)
35 data2.attach(view1)
36
37 print "Setting Data 1 = 10"
38 data1.setData(10)
39 print "Setting Data 2 = 15"
40 data2.setData(15)
41 print "Setting Data 1 = 3"
42 data1.setData(3)
43 print "Setting Data 2 = 5"
44 data2.setData(5)
45 print "Detach HexViewer from data1 and data2."
46 data1.detach(view2)
47 data2.detach(view2)
48 print "Setting Data 1 = 10"
49 data1.setData(10)
50 print "Setting Data 2 = 15"
51 data2.setData(15)
Template Method（模板方法）
意图
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
实现代码
Visitor(访问者）
意图
作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.
实现代码
1 class Visitor:
2 def __init__(self):
3 self._methodDic={}
4
5 def default(self, other):
6 print "What's this:", other
7
8 def addMethod(self, method):
9 self._methodDic[method.getKey()]=method
10
11 def __call__(self, other):
12 method=self._methodDic.get(\
13 other.__class__.__name__,self.default)
14 return method(other)
用法、例子
在MyVisit的函数call中定义对target的具体访问操作。
1 class MyVisit:
2 """
3 Instead of deriving from Visitor the work is
4 done by instances with this interface.
5 """
6 def __init__(self, otherClass):
7 self._msg='Visit: %s'%otherClass.__name__
8 self._key=otherClass.__name__
9
10 def __call__(self, target):
11 print self._msg, target
12
13 def getKey(self):
14 return self._key
15
16 # 被访问者
17 class E1:pass
18 class E2:pass
19 class E3:pass
20
21 # 用法
22
23 collection=[E1(), E1(), E2(), E3()]
24
25 visitor=Visitor()
26 visitor.addMethod(MyVisit(E1))
27 visitor.addMethod(MyVisit(E2))
28
29 map(visitor, collection)
输出：
Visit: E1 <main.E1 instance at 7ff6d0>
Visit: E1 <main.E1 instance at 7ff730>
Visit: E2 <main.E2 instance at 7ff780>
What's this: <main.E3 instance at 7ff7b0>
# 简化用法
输出：
Visit: E1 <main.E1 instance at 0x00A91EE0>
Command（命令）
意图
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。在python中叫“Command Dispatch Pattern”，也不需要将请求封装成对象，直接用字符串作命令请求。
实现代码
用法
state（代理）
意图
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
实现代码
1 class NetworkCardState:
2 """Abstract State Object"""
3 def send(self):
4 raise "NetworkCardState.send - not overwritten"
5
6 def receive(self):
7 raise "NetworkCardState.receive - not overwritten"
8
9
10 class Online(NetworkCardState):
11 """Online state for NetworkCard"""
12 def send(self):
13 print "sending Data"
14
15 def receive(self):
16 print "receiving Data"
17
18
19 class Offline(NetworkCardState):
20 """Offline state for NetworkCard"""
21 def send(self):
22 print "cannot send...Offline"
23
24 def receive(self):
25 print "cannot receive...Offline"
26
27
28 class NetworkCard:
29 def __init__(self):
30 self.online = Online()
31 self.offline = Offline()
32 ##default state is Offline
33 self.currentState = self.offline
34
35 def startConnection(self):
36 self.currentState = self.online
37
38 def stopConnection(self):
39 self.currentState = self.offline
40
41 def send(self):
42 self.currentState.send()
43
44 def receive(self):
45 self.currentState.receive()
46
47
48 def main():
49 myNetworkCard = NetworkCard()
50 print "without connection:"
51 myNetworkCard.send()
52 myNetworkCard.receive()
53 print "starting connection"
54 myNetworkCard.startConnection()
55 myNetworkCard.send()
56 myNetworkCard.receive()
57
58 if __name__ == '__main__':
59 main()
interpreter（解释器）
意图
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示 来解释语言中的句子。