Patron Observer

Fait partie de la section Programmation orientée objet du Journey Python de Coddy. Leçon 47 sur 64.

Le patron Observateur crée une relation un-à-plusieurs dans laquelle un objet (sujet) informe plusieurs objets (observateurs) lorsque son état change.

Voici une classe Subject simple qui gère des observateurs :

class Subject:
    def __init__(self):
        self._observers = []
    
    def add_observer(self, observer):
        self._observers.append(observer)
    
    def notify(self, message):
        for observer in self._observers:
            observer.update(message)

Le sujet conserve une liste d’observateurs et peut tous les notifier en une seule fois.

Créez des classes observatrices simples :

class EmailNotifier:
    def update(self, message):
        print(f"Email sent: {message}")

class SMSNotifier:
    def update(self, message):
        print(f"SMS sent: {message}")

Chaque observateur possède une méthode update qui est appelée lorsqu’il est notifié.

Utilisez le modèle d’observateur :

# Créer le sujet
news = Subject()

# Créer les observateurs
email = EmailNotifier()
sms = SMSNotifier()

# Ajouter les observateurs au sujet
news.add_observer(email)
news.add_observer(sms)

# Notifier tous les observateurs
news.notify("Breaking news: Python is awesome!")

Créez un exemple pratique avec un suivi du cours d’une action :

class Stock:
    def __init__(self, symbol, price):
        self.symbol = symbol
        self._price = price
        self._observers = []
    
    def add_observer(self, observer):
        self._observers.append(observer)
    
    def set_price(self, price):
        self._price = price
        self.notify()
    
    def notify(self):
        for observer in self._observers:
            observer.update(self.symbol, self._price)

class Investor:
    def __init__(self, name):
        self.name = name
    
    def update(self, symbol, price):
        print(f"{self.name} notified: {symbol} is now ${price}")

# Utiliser le tracker d'actions
apple_stock = Stock("AAPL", 150)

investor1 = Investor("Alice")
investor2 = Investor("Bob")

apple_stock.add_observer(investor1)
apple_stock.add_observer(investor2)

apple_stock.set_price(155)  # Notifie tous les investisseurs

Sortie :

Email sent: Breaking news: Python is awesome!
SMS sent: Breaking news: Python is awesome!
Alice notified: AAPL is now $155
Bob notified: AAPL is now $155

Point clé : le modèle Observateur permet à un objet d’en notifier automatiquement plusieurs autres lorsqu’un changement survient. Le sujet gère une liste d’observateurs et appelle leur méthode update lorsque cela est nécessaire. Cela est utile pour les notifications, les systèmes d’événements et pour maintenir synchronisées plusieurs parties de votre application.

Défi

Moyen

Implémentez le modèle Observer en créant un système de surveillance météorologique. Vous devez créer deux classes dans les zones désignées du code.

Étape 1 : Créer la classe WeatherStation

Écrivez votre classe WeatherStation à l’endroit indiqué par le commentaire. Cette classe doit :

Hériter de la classe Subject (utilisez class WeatherStation(Subject):)
S’initialiser avec :
- Appelez le constructeur parent à l’aide de super().__init__()
- Définissez la température initiale sur 0 à l’aide de l’attribut à un seul trait de soulignement self._temperature (la convention Python pour un attribut interne)
Implémentez set_temperature(self, temperature) :
- Mettez à jour l’attribut de température interne
- Appelez self.notify(self._temperature) pour notifier tous les observateurs
Implémentez get_temperature(self) :
- Renvoyez la valeur actuelle de la température

Étape 2 : Créer la classe WeatherDisplay

Écrivez votre classe WeatherDisplay à l’endroit indiqué par le commentaire. Cette classe doit :

Hériter de la classe Observer (utilisez class WeatherDisplay(Observer):)
S’initialiser avec :
- Acceptez un paramètre name
- Stockez le nom dans self.name
Implémentez update(self, temperature) :
- Affichez le message de mise à jour de la température exactement dans le format indiqué ci-dessous

Format du message :

Lorsqu’un affichage reçoit une mise à jour de la température, il doit afficher exactement :

Display [name]: Current temperature is [temperature]C

Exemple d’utilisation :

# Créer la station météo et les affichages
station = WeatherStation()
phone_display = WeatherDisplay("Phone")
tablet_display = WeatherDisplay("Tablet")

# Attacher les affichages à la station
station.attach(phone_display)
station.attach(tablet_display)

# Mettre à jour la température - les deux affichages seront notifiés
station.set_temperature(25.5)

# Sortie :
# Display Phone: Current temperature is 25.5C
# Display Tablet: Current temperature is 25.5C

Remarques importantes :

Les méthodes attach() et detach() sont déjà implémentées dans la classe de base Subject ; vous n’avez pas besoin de les implémenter ni de les appeler dans votre classe WeatherStation
Dans l’exemple d’utilisation ci-dessus, station.attach(phone_display) est appelé par l’utilisateur de votre classe, et non à l’intérieur de votre implémentation de WeatherStation
Votre WeatherStation doit simplement appeler self.notify() lorsque la température change ; la classe de base Subject s’occupe du reste
Concentrez-vous sur l’implémentation des trois méthodes requises dans WeatherStation et des deux méthodes requises dans WeatherDisplay, comme indiqué ci-dessus

Essayez vous-même

class Subject:
    def __init__(self):
        self._observers = []
    
    def attach(self, observer):
        self._observers.append(observer)
        
    def detach(self, observer):
        self._observers.remove(observer)
        
    def notify(self, data):
        for observer in self._observers:
            observer.update(data)
            
class Observer:
    def update(self, data):
        pass

# Écrivez votre classe WeatherStation ici

# Écrivez votre classe WeatherDisplay ici