The Observer pattern is mainly used to implement a distributed event handling system. The primary objective of this pattern is to provide a way to handle run-time one-to-many relationships between objects in a loosely coupled arrangement.
In this configuration, the Observable object doesn't know anything more about it's Observers than a very limited interface. The Observable needs to provide a wide interface for allowing other objects to gain access to it's current state.
The event from the observable object's point of view is called notification and the event from the observers' point of view is called update.
class Observable( object ):attach_observer and detach_observer maintain the list of Observers that are interested in this object. After any change in state, notify_all should be called. If this state change is part of a larger transaction, the combination set_dirty and notify_check should be called.
def __init__( self, *args, **kwargs ):
super( Observable, self ).__init__( *args, **kwargs )
self.__dirty = False
self.__observers = weakref.WeakKeyDictionary( )
def attach_observer( self, obs ):
if obs not in self.__observers:
self.__observers[obs] = 1
def detach_observer( self, obs ):
if obs in self.__observers:
def set_dirty( self, d ):
self.__dirty = d
def is_dirty( self ):
def notify_all( self ):
for observer in self.__observers.keys( ):
observer.observer_update( self )
def notify_check( self ):
if self.is_dirty( ):
self.set_dirty( False )
If you're also using Stackless python, you may want to have notify_all use the event-loop mechanism we've previously discussed.
The Observer object is very easy to implement. Really, only it needs observer_udpate defined since that method is called by Observable during notify_all. The observed object passes itself as the argument to observable_update so that the observer knows which of the objects it currently is observing has been updated.
class Observer( object ):
def __init__(self, *args, **kwargs ):
def observer_update( self, object ):