Writing observer pattern structure in Python program

Observer pattern definition

defines one-to-many dependencies between objects, so that when an object changes state, all its dependencies will be collected to notifications and automatically updated. The Observer pattern provides an object design that provides loose coupling between subjects and observers.
Design principles
Strive for loose coupling design between interactive objects. The reason why loosely coupled design allows us to build a flexible system that can cope with changes is because the interdependence between objects is reduced to a minimum.

Mode structure and description

1.Subject: Topic (target) interface, topics can be registered and removed Observers who are interested in it can also notify these observers when their own data changes. A subject can have multiple observers, it is important to note that the order of observers should not matter. The subject is also called the "observable" (Observable)
2. All observers must implement the Observer interface so that they can be notified when the subject status changes
The observer pattern is a widely used, very An important design pattern that helps reduce coupling between objects while allowing objects to maintain a high degree of collaboration. The loose coupling characteristics of this pattern are reflected in:
1. Everything about the observer, the subject only knows that it implements the observer interface, and nothing else is known.
2. At any time, the subject's observer can be dynamically Adding and deleting
3. When a new type of observer appears, the code of the topic does not need to be modified
4. Modifying either the topic or the observer will not affect the other party

Example
You can understand it clearly through comments~

#observer pattern 
 
class subject():
  def __init__(self,dat):
    self.listobj = list() #主题中的列表变量用来存储观察者
    self.dat = dat #主题中的数据变化时，需要通知观察者
    
  def registerObject(self,obj):
    self.listobj.append(obj) #实现订阅主题的函数
    
  def removeObject(self,obj):
    pass
  
  def notifyObservers(self):#通知各个观察者数据已经发生变化，观察者相应需要更新自己的数据
    for i in range(len(self.listobj)):
      self.listobj[i].update()
      
  def setdat(self,new_dat):#设置数据
    if self.dat != new_dat:
      self.dat = new_dat
      self.notifyObservers()
 
class observer():#观察者
  def __init__(self,sub): #观察者初始化时，需要订阅主题
    self.sub = sub
    self.sub.registerObject(self)
    self.number = self.sub.dat
    
  def update(self):#观察者更新
    self.number = self.sub.dat
  def display(self):
    print self.number
    
if __name__ =="__main__":
  su = subject(10)
  ob1 = observer(su)
  ob1.display()
  ob2 = observer(su)
  ob2.display()
  su.setdat(11)
  ob1.display()
  ob2.display()

More Python For articles related to writing observer pattern structures in programs, please pay attention to the PHP Chinese website!