Écriture d'une structure de modèle d'observateur dans un programme Python

La définition du modèle d'observateur

définit des dépendances un à plusieurs entre les objets, de sorte que lorsqu'un objet change d'état, toutes ses dépendances seront collectées dans les notifications et automatiquement mis à jour. Le modèle Observer fournit une conception d’objet qui assure un couplage lâche entre les sujets et les observateurs.
Principes de conception
Efforcez-vous d'obtenir une conception à couplage lâche entre les objets interactifs. La raison pour laquelle une conception faiblement couplée nous permet de construire un système flexible capable de faire face aux changements est que l'interdépendance entre les objets est réduite au minimum.

Structure et description du mode

1.Sujet : interface de sujet (cible), les sujets peuvent être enregistrés et supprimés Les observateurs qui s'y intéressent peuvent également avertir ces observateurs lorsque leurs propres données changent. Un sujet peut avoir plusieurs observateurs, mais il convient de noter que l’ordre des observateurs n’a pas d’importance. Le sujet est également appelé "observable" (Observable)
2. Tous les observateurs doivent implémenter l'interface Observer afin qu'ils puissent être avertis lorsque le statut du sujet change
Le modèle d'observateur est une conception largement utilisée et très importante. modèle qui permet de réduire le couplage entre les objets tout en permettant aux objets de maintenir un degré élevé de collaboration. Les caractéristiques de couplage lâche de ce modèle se reflètent dans :
1. Tout ce qui concerne l'observateur, le sujet sait seulement qu'il implémente l'interface de l'observateur, et rien d'autre n'est connu
2. À tout moment, l'observateur du sujet peut être ajouté et supprimé dynamiquement
3. Lorsqu'un nouveau type d'observateur apparaît, le code du thème n'a pas besoin d'être modifié
4. Modifiez soit le sujet, soit l'observateur, l'autre ne sera pas affecté

Exemple
Vous pouvez comprendre clairement à travers les commentaires~

#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()

Plus Pour les articles liés à l'écriture de structures de modèles d'observateurs dans plusieurs programmes Python, veuillez faire attention au site Web PHP chinois !