<\/div> <\/div><\/p>\n
2.1 Define Observer and Subject Interfaces<\/h3>\n
This file defines the abstract base classes for Observer and Subject. It sets the blueprint for concrete implementations of the pattern. Observers will implement an update method, and Subjects will implement attach, detach, and notify methods.<\/p>\n
\n# observer_subject.py\nfrom abc import ABC, abstractmethod\n\n\n# Observer interface\nclass Observer(ABC):\n @abstractmethod\n def update(self, message):\n pass\n\n\n# Subject interface\nclass Subject(ABC):\n @abstractmethod\n def attach(self, observer):\n pass\n\n @abstractmethod\n def detach(self, observer):\n pass\n\n @abstractmethod\n def notify(self):\n pass\n<\/pre>\nThis file defines the abstract base classes for the Observer Pattern. The Observer<\/code> class requires an update()<\/code> method, which every concrete observer must implement to receive notifications. The Subject<\/code> class defines the interface for managing observers with attach()<\/code>, detach()<\/code>, and notify()<\/code> methods. Using these abstract classes ensures that any concrete subject or observer follows a consistent interface, making the system modular and extendable.<\/p>\n2.2 Implement the Concrete Subject<\/h3>\n
This file implements a concrete Subject called NewsPublisher. It maintains a list of observers and manages notifications. Whenever new news is added, it automatically notifies all subscribed observers about the update.<\/p>\n
\n# news_publisher.py\n\n# Concrete Subject\nclass NewsPublisher(Subject):\n def __init__(self):\n self._observers = []\n self._latest_news = None\n\n def attach(self, observer):\n if observer not in self._observers:\n self._observers.append(observer)\n\n def detach(self, observer):\n if observer in self._observers:\n self._observers.remove(observer)\n\n def notify(self):\n for observer in self._observers:\n observer.update(self._latest_news)\n\n def add_news(self, news):\n self._latest_news = news\n self.notify()\n<\/pre>\nThis file implements the concrete subject NewsPublisher<\/code> that inherits from the abstract Subject<\/code> class. It maintains a private list of observers and a variable for the latest news. The attach()<\/code> and detach()<\/code> methods allow observers to subscribe and unsubscribe, while the notify()<\/code> method sends the latest news to all current observers. The add_news()<\/code> method updates the news and triggers the notification, enabling automatic updates in a push observer model.<\/p>\n2.3 Implement Concrete Observers<\/h3>\n
This file defines concrete Observers that subscribe to the NewsPublisher. Each observer implements the update method differently. EmailSubscriber sends updates via email format, and SMSSubscriber sends updates via SMS format.<\/p>\n
\n# subscribers.py\n\n# Concrete Observers\nclass EmailSubscriber(Observer):\n def __init__(self, name):\n self.name = name\n\n def update(self, message):\n print(f\"{self.name} received email notification: {message}\")\n\n\nclass SMSSubscriber(Observer):\n def __init__(self, name):\n self.name = name\n\n def update(self, message):\n print(f\"{self.name} received SMS notification: {message}\")\n<\/pre>\nThis file contains the concrete observer implementations EmailSubscriber<\/code> and SMSSubscriber<\/code>, both inheriting from the Observer<\/code> abstract class. Each class implements the update()<\/code> method differently to display notifications in a specific format, such as email or SMS. When the subject publishes news, these observers receive updates according to their respective implementations, demonstrating the flexibility of the observer pattern in handling multiple types of notifications.<\/p>\n2.4 Demonstration and Handling Unsubscribes<\/h3>\n
This is the main script that demonstrates the Observer Pattern in action. Observers are attached, notified, and unsubscribed dynamically. It shows how updates propagate from the subject to observers and how detaching an observer prevents future notifications.<\/p>\n
\n# main.py\n\nfrom news_publisher import NewsPublisher\nfrom subscribers import EmailSubscriber, SMSSubscriber\n\n# Create subject\nnews_publisher = NewsPublisher()\n\n# Create observers\nalice = EmailSubscriber(\"Alice\")\nbob = SMSSubscriber(\"Bob\")\n\n# Subscribe observers\nnews_publisher.attach(alice)\nnews_publisher.attach(bob)\n\n# Publish news\nnews_publisher.add_news(\"Python 4.0 released!\")\n\n# Unsubscribe Bob\nnews_publisher.detach(bob)\n\n# Publish another news\nnews_publisher.add_news(\"New AI framework announced!\")\n<\/pre>\nThis is the main script that brings all components together and runs the observer pattern example. It creates a NewsPublisher<\/code> instance and two observers, EmailSubscriber<\/code> and SMSSubscriber<\/code>. The observers are attached to the publisher and receive notifications whenever news is added using add_news()<\/code>. The script also demonstrates dynamic unsubscription by detaching one observer before publishing another news update, illustrating how the pattern handles real-time subscription changes.<\/p>\n2.5 Code Run and Output<\/h3>\n
After implementing all the classes in separate files and connecting them in main.py<\/code>, running the script will demonstrate the Observer Pattern in action. When the NewsPublisher<\/code> publishes a news item using add_news()<\/code>, all currently subscribed observers receive the notification immediately via their update()<\/code> method. In this example, both Alice (EmailSubscriber) and Bob (SMSSubscriber) initially receive the first news update. After Bob is detached using detach()<\/code>, only Alice receives the second update. The expected output is displayed in the console as follows:<\/p>\n\nAlice received email notification: Python 4.0 released!\nBob received SMS notification: Python 4.0 released!\nAlice received email notification: New AI framework announced!\n<\/pre>\nThis output confirms the push observer model is working correctly: the subject actively sends updates to all subscribed observers, and unsubscribed observers no longer receive notifications. The script demonstrates real-time notification handling, dynamic subscription management, and the flexibility of the Observer Pattern in Python.<\/p>\n