Introduction to visitor and observer pattern examples in Python design pattern programming

This article mainly introduces the visitor and observer pattern in PythonDesign PatternProgramming, and the formulation of the design pattern It is conducive to the coordination of team collaboration programming code. Friends who need it can refer to

Visitor mode
I think the Visitor mode is to modify the existing program. Under the premise of structure, why is it used to expand the function of the code by adding additional visitors? When you have many classes and add new methods to a certain layer of structure, if you add or change the base class, it may destroy the original design and cause compatibility issues, so only add it dynamically to the required classes.

Python example
Here is an example of building a car. Each component has an accept method to accept the so-called 'visitor' I mentioned above, and this visitor is passed in as a parameter. But in fact, it is an instance of a class that contains some functions. It has many methods starting with visit corresponding to different components. This way there is no need to modify these components, only the relevant parts of our visitor class.

# 轮子,引擎, 车身这些定义好了都不需要变动
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 pattern
When we want the state of an object If a change occurs, then the dependency and all its objects can change accordingly (get notified), then the Observer pattern can be used, in which these dependent objects are the objects of the observer, and the object that is to change is the so-called 'observer'

python example

# 这个是观察者基类
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

The above is the detailed content of Introduction to visitor and observer pattern examples in Python design pattern programming. For more information, please follow other related articles on the PHP Chinese website!