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 ): 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 return self def detach_observer( self, obs ): if obs in self.__observers: del self.__observers[obs] return self def set_dirty( self, d ): self.__dirty = d return self.__dirty def is_dirty( self ): return self.__dirty def notify_all( self ): for observer in self.__observers.keys( ): observer.observer_update( self ) def notify_check( self ): if self.is_dirty( ): self.notify_all( ) self.set_dirty( False )
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.
class Observer( object ): def __init__(self, *args, **kwargs ): pass def observer_update( self, object ): pass
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.