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

   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

   1 class MyClass(object):
   2     __metaclass__ = Singleton
   3 
   4 ob1 = MyClass()
   5 ob2 = MyClass()
   6 assert ob1 is ob2

   1 class Proxy:
   2     def __init__( self, subject ):
   3         self.__subject = subject
   4     def __getattr__( self, name ):
   5         return getattr( self.__subject, name )   

   1 class RGB:
   2     def __init__( self, red, green, blue ):
   3         self.__red = red
   4         self.__green = green
   5         self.__blue = blue
   6     def Red( self ):
   7         return self.__red
   8     def Green( self ):
   9         return self.__green
  10     def Blue( self ):
  11         return self.__blue 

   1 class NoBlueProxy( Proxy ):
   2     def Blue( self ):
   3         return 0

   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 )   

   1 class MainWindow(Widget):
   2     def Handle_close( self, event ):
   3         print 'MainWindow: ' + event.name
   4     def HandleDefault( self, event ):
   5         print 'Default: ' + event.name
   6         
   7 class Button( Widget ):
   8     def Handle_click( self, event ):
   9         print 'Button: ' + event.name

   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)

   1 class Base:
   2     def doAll(self):
   3         self.doThis()
   4         self.doThat()
   5     
   6 class Foo(Base):
   7     def doThis(self):
   8         print "do this"
   9     def doThat(self):
  10         print "do that"
  11 
  12 #测试
  13 Foo a
  14 a.doAll()
  15 #输出
  16 #do this
  17 #do that

   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)

   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)

   1 visitor = Visitor()
   2 visitor.addMethod(MyVisit(E1))
   3 a = E1()
   4 visitor(a)

   1 class Dispatcher:
   2 
   3     def do_get(self):
   4             print("do_get")
   5 
   6     def do_put(self):
   7             print("d0_put")
   8                         
   9     def error(self):
  10             print("error")
  11 
  12     def dispatch(self, command):
  13         mname = 'do_' + command
  14         if hasattr(self, mname):
  15             method = getattr(self, mname)
  16             method()
  17         else:
  18             self.error()

   1 Dispatcher a
   2 a.dispatch("get")
   3 a.dispatch("put")

   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()