python的例子
这里是个构建车的例子，每个部件都有一个accept的方法接受我上面说的所谓'访问者'，而这个访问者 以参数的方式传进来，但是其实他是一个含有一些功能的类的实例，它拥有很多个visit开头的方法对应不同的部件。 这样就不需要修改这些部件，而只是修改我们的访问者类的相关部分。

# 轮子,引擎, 车身这些定义好了都不需要变动
class Wheel:
 def __init__(self, name):
 self.name = name
 def accept(self, visitor):
 # 每个visitor是同样的，但是其中的方法是不一样的，比如这里是visitWheel，
 # 然后传入了self，想想？他其实想做什么就能做什么
 visitor.visitWheel(self)

class Engine:
 def accept(self, visitor):
 visitor.visitEngine(self)

class Body:
 def accept(self, visitor):
 visitor.visitBody(self)

# 我们要组合成车
class Car:
 def __init__(self):
 self.engine = Engine()
 self.body = Body()
 self.wheels = [ Wheel("front left"), Wheel("front right"),
 Wheel("back left") , Wheel("back right") ]

 # 这个也不需要在动，他只是上面部件的组合，只是做了属性的委托
 def accept(self,visitor):
 visitor.visitCar(self)
 self.engine.accept(visitor)
 self.body.accept(visitor)
 for wheel in self.wheels:
 wheel.accept(visitor)

# 这个才是我们的访问者，每次的修改都在这里面
class PrintVisitor:
 def visitWheel(self, wheel):
 print "Visiting "+wheel.name+" wheel"
 def visitEngine(self, engine):
 print "Visiting engine"
 def visitBody(self, body):
 print "Visiting body"
 def visitCar(self, car):
 print "Visiting car"

if __name__ == '__main__':
 car = Car()
 visitor = PrintVisitor()
 car.accept(visitor)

观察者模式
当我们希望一个对象的状态发生变化，那么依赖与它的所有对象都能相应变化(获得通知),那么就可以用到Observer模式， 其中的这些依赖对象就是观察者的对象，那个要发生变化的对象就是所谓'观察者'

python的例子

# 这个是观察者基类
class Subject(object):
 def __init__(self):
 self._observers = []

 # 添加依赖的对象
 def attach(self, observer):
 if not observer in self._observers:
 self._observers.append(observer)

 # 取消添加
 def detach(self, observer):
 try:
 self._observers.remove(observer)
 except ValueError:
 pass

 # 这里只是通知上面注册的依赖对象新的变化
 def notify(self, modifier=None):
 for observer in self._observers:
 # 可以设置过滤条件，对不符合过滤条件的更新
 if modifier != observer:
 observer.update(self)


# 观察者类
class Data(Subject):
 def __init__(self, name=''):
 super(Data, self).__init__()
 self.name = name
 self._data = 0

 # python2.6新增的写法,获取属性为property，设置属性为(假设属性名字为x)@x.setter,删除为@x.deleter
 @property
 def data(self):
 return self._data

 @data.setter
 def data(self, value):
 self._data = value
 self.notify()

# 这里有2个被观察者，也就是依赖的对象，每次Data有改变，这2个view都会变动
class HexViewer(object):
 def update(self, subject):
 print 'HexViewer: Subject %s has data 0x%x' % (subject.name, subject.data)

class DecimalViewer(object):
 def update(self, subject):
 print 'DecimalViewer: Subject %s has data %d' % (subject.name, subject.data)


if __name__ == '__main__':

 data1 = Data('Data 1')
 data2 = Data('Data 2')
 view1 = DecimalViewer()
 view2 = HexViewer()
 data1.attach(view1)
 data1.attach(view2)
 data2.attach(view2)
 data2.attach(view1)

 print "Setting Data 1 = 10"
 data1.data = 10
 print "Setting Data 2 = 15"
 data2.data = 15
 print "Setting Data 1 = 3"
 data1.data = 3
 print "Setting Data 2 = 5"
 data2.data = 5
 print "Update data1's view2 Because view1 is be filtered"
 data1.notify(modifier=view1) 
 print "Detach HexViewer from data1 and data2."
 data1.detach(view2)
 data2.detach(view2)
 print "Setting Data 1 = 10"
 data1.data = 10
 print "Setting Data 2 = 15"
 data2.data = 15