Patron Observer

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

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

Voici une simple classe Subject 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 même temps.

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 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ée 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}")

# Utilisez le suivi des 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 Observer permet à un objet d’en informer automatiquement plusieurs autres lorsqu’un changement survient. Le sujet maintient une liste d’observateurs et appelle leur méthode update lorsque nécessaire. Cela est utile pour les notifications, les systèmes d’événements et pour synchroniser plusieurs parties de votre application.

Défi

Moyen

Implémentez le modèle Observateur 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 :
- Appeler le constructeur parent à l’aide de super().__init__()
- Définir la température initiale à 0 à l’aide de l’attribut à un seul trait de soulignement self._temperature (convention Python pour un attribut interne)
Implémenter set_temperature(self, temperature) :
- Mettre à jour l’attribut de température interne
- Appeler self.notify(self._temperature) pour notifier tous les observateurs
Implémenter get_temperature(self) :
- Renvoyer 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 :
- Accepter un paramètre name
- Enregistrer le nom dans self.name
Implémenter update(self, temperature) :
- Afficher le message de mise à jour de la température dans le format exact indiqué ci-dessous

Format du message :

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

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

Exemple d’utilisation :

# Create weather station and displays
station = WeatherStation()
phone_display = WeatherDisplay("Phone")
tablet_display = WeatherDisplay("Tablet")

# Attach displays to station
station.attach(phone_display)
station.attach(tablet_display)

# Update temperature - both displays will be notified
station.set_temperature(25.5)

# Output:
# 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

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Programmation orientée objet

3Propriétés de classe

Variables d'instance vs variables de classe Décorateurs de propriété Attributs privés Récapitulatif - Gestionnaire de compte bancaire

6Encapsulation

Membres Publics, Protégés, Privés Modificateurs d'accès Masquage d'informations Décorateurs Property Avancés Récapitulatif - Système de Gestion d'Étudiants

9Arguments avancés

Les *args Les **kwarg

12Projet : Gestion de bibliothèque

Présentation du projet Classes Livre et Utilisateur Système d'emprunt Fonctionnalité de recherche Interface d'administration Tests et intégration

Entraînez-vous par vous-même : Compilateur Python en ligne