Mode observateur d'apprentissage Python

Cet article parle principalement du mode observateur de Python. Le code a une certaine valeur de référence. Les amis intéressés peuvent en apprendre davantage.

Demande : les employés examinent secrètement les stocks au travail. Veuillez demander à la réception de les avertir dès l'arrivée du patron et leur demander d'arrêter de regarder les stocks.

Il y a deux types de personnes ici, l'une est l'observateur, c'est-à-dire l'employé, et l'autre est le notifiant, c'est-à-dire la réception. et la réception est chargée d'informer les employés des derniers développements.

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'

class Receptionist():
    def __init__(self):
        self.observes=[]
        self.status=''
    def attach(self,observe):
        self.observes.append(observe)
    def notify(self):
        for observe in self.observes:
            observe.update()

class StockObserve():
    def __init__(self,name,receptionist):
        self.name=name
        self.receptionist=receptionist
    def update(self):
        print '%s,%s停止看股票'%(self.receptionist.status,self.name)

if __name__=='__main__':
    receptionist=Receptionist()
    observe1=StockObserve('张三',receptionist)
    observe2=StockObserve('李四',receptionist)
    receptionist.attach(observe1)
    receptionist.attach(observe2)

    receptionist.status='老板来了'
    receptionist.notify()

Le couplage entre les deux classes ici est très large, et elles sont interdépendantes. D'une part, la méthode notify de la classe foreground appellera la méthode update de la classe stock observer. D'autre part, la classe observer accédera à l'attribut status de la classe foreground pour obtenir les derniers développements.

Lorsque la demande change, par exemple, le patron peut désormais également être le notifiant. En plus de surveiller les actions, les employés surveilleront également la NBA si une classe Boss et une classe NBAObserver sont ajoutées, le couplage de ces quatre classes. sera très serré. , la maintenance ultérieure sera très difficile, donc lorsque vous rencontrez une situation de couplage aussi serrée, il est nécessaire d'abstraire leurs parties couplées dans une classe parent, afin que la maintenance ultérieure soit beaucoup plus facile

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'
from abc import ABCMeta, abstractmethod

class Subject():
    __metaclass__ = ABCMeta
    observers=[]
    status=''
    @abstractmethod
    def attach(self,observer):
        pass
    @abstractmethod
    def detach(self,observer):
        pass
    @abstractmethod
    def notify(self):
        pass

class Observer():
    __metaclass__ = ABCMeta
    def __init__(self,name,sub):
        self.name=name
        self.sub=sub
    @abstractmethod
    def update(self):
        pass

class Boss(Subject):
    def __init__(self):
        pass
    def attach(self,observer):
        self.observers.append(observer)

    def detach(self,observer):
        self.observers.remove(observer)
    def notify(self):
        for observer in self.observers:
            observer.update()

class StockObserver(Observer):
    def update(self):
        print '%s,%s停止看股票'%(self.sub.status,self.name)
class NBAObserver(Observer):
    def update(self):
        print '%s,%s停止看NBA'%(self.sub.status,self.name)

if __name__=='__main__':
    boss=Boss()
    observe1=StockObserver('张三',boss)
    observe2=NBAObserver('李四',boss)
    boss.attach(observe1)
    boss.attach(observe2)
    boss.detach(observe2)
    boss.status='我是老板，我来了'
    boss.notify()

Tutoriels associés : Tutoriel vidéo Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!