Python-Lernbeobachtermodus

In diesem Artikel geht es hauptsächlich um den Beobachtermodus von Python. Ich hoffe, dass der Code für interessierte Freunde hilfreich sein kann.

Forderung: Mitarbeiter schauen sich am Arbeitsplatz heimlich Aktien an. Bitten Sie die Rezeption, sie zu benachrichtigen, sobald der Chef hereinkommt, und bitten Sie sie, mit der Suche nach Aktien aufzuhören.

Hier gibt es zwei Arten von Menschen, eine ist der Beobachter, also der Mitarbeiter, und die andere ist der Melder, also die Rezeption. Die Mitarbeiter beobachten den Status der Rezeption. und die Rezeption ist dafür verantwortlich, die Mitarbeiter über die neuesten Entwicklungen zu informieren.

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

Die Kopplung zwischen den beiden Klassen ist hier sehr groß und sie sind voneinander abhängig. Einerseits ruft die Benachrichtigungsmethode der Vordergrundklasse die Aktualisierungsmethode der Aktienbeobachterklasse auf. Andererseits greift die Beobachterklasse auf das Statusattribut der Vordergrundklasse zu, um die neuesten Entwicklungen zu erhalten.

Wenn sich beispielsweise die Nachfrage ändert, kann der Chef nun zusätzlich zum Beobachten von Aktien auch NBA beobachten. Wenn eine Boss-Klasse und eine NBAObserver-Klasse hinzugefügt werden, erfolgt die Kopplung dieser vier Klassen Wird sehr eng sein, wird die spätere Wartung sehr schwierig sein. Wenn Sie also auf eine so enge Kopplungssituation stoßen, ist es notwendig, ihre gekoppelten Teile in eine übergeordnete Klasse zu abstrahieren, damit die spätere Wartung viel einfacher wird

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

Verwandte Tutorials: Python-Video-Tutorial

Das obige ist der detaillierte Inhalt vonPython-Lernbeobachtermodus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!