No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Patrón Observer en Python

23/27
Recursos

Aportes 4

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

El patrón Observer se estructura en tres componentes principales: 1. **Interfaz Listener**: Define el método `update()`, el cual será implementado por los objetos que quieren recibir actualizaciones. 2. **Clase Manager (Subject)**: Gestiona a los observadores. Tiene métodos para agregar, eliminar y notificar a los listeners cuando ocurre un evento. 3. **Clases Observadoras**: Implementan la interfaz Listener y definen la lógica que se ejecutará cuando sean notificadas. Este patrón se usa para implementar sistemas de eventos donde múltiples objetos necesitan estar al tanto de los cambios en otro objeto.
El patrón Observer es un patrón de diseño de comportamiento que permite a un objeto (el sujeto) notificar a otros objetos (los observadores) sobre cambios en su estado. Esto es útil en situaciones donde un cambio en un objeto requiere la actualización de otros objetos. En Python, se define una interfaz `Listener` con un método `update`, que los observadores implementan. Un `Manager` gestiona la suscripción y notificación de los observadores, permitiendo que el sujeto los notifique cuando suceden eventos relevantes. Este patrón es ideal para sistemas de eventos y notificaciones automáticas.
El \*\*Patrón Observer\*\* es un patrón de diseño de comportamiento que define una relación de dependencia entre objetos, de manera que cuando un objeto cambia de estado (el *\*subject\**), todos los objetos que dependen de él (los *\*observers\**) son notificados automáticamente. Este patrón es útil para escenarios donde múltiples objetos deben reaccionar a los cambios en otro objeto sin acoplarse estrechamente. \### Ejemplo Clásico: Sistema de Notificaciones Vamos a implementar un sistema donde varios *\*observers\** (como usuarios o servicios) sean notificados cuando un sistema de pagos cambie de estado, por ejemplo, cuando se procese un pago. \### Paso 1: Definir el Subject El \*\*Subject\*\* es el objeto principal al que los observadores se suscriben. ```pythonclass Subject:    def \_\_init\_\_(self):        self.\_observers = \[]     def attach(self, observer):        """Agrega un observer a la lista."""        self.\_observers.append(observer)     def detach(self, observer):        """Elimina un observer de la lista."""        self.\_observers.remove(observer)     def notify(self, message):        """Notifica a todos los observers."""        for observer in self.\_observers:            observer.update(message)``` \### Paso 2: Definir la Interfaz del Observer Cada \*\*Observer\*\* debe implementar un método `update` que será llamado por el Subject. ```pythonfrom abc import ABC, abstractmethod class Observer(ABC):    @abstractmethod    def update(self, message):        pass``` \### Paso 3: Implementar Observers Concretos Crea clases concretas que implementen la interfaz del Observer. ```pythonclass EmailNotifier(Observer):    def update(self, message):        print(f"EmailNotifier: Enviando email con el mensaje: '{message}'") class SMSNotifier(Observer):    def update(self, message):        print(f"SMSNotifier: Enviando SMS con el mensaje: '{message}'") class LogNotifier(Observer):    def update(self, message):        print(f"LogNotifier: Registrando en el log: '{message}'")``` \### Paso 4: Usar el Patrón Observer Ahora conectemos todo. Supongamos que tenemos un sistema de pagos que notifica a los observadores cuando un pago se procesa. ```pythonclass PaymentSystem(Subject):    def process\_payment(self, amount, method):        print(f"Procesando pago de {amount} usando {method}.")        self.notify(f"Pago de {amount} procesado con {method}.")``` \#### Código Principal ```python# Crear un sistema de pagospayment\_system = PaymentSystem() \# Crear observersemail\_notifier = EmailNotifier()sms\_notifier = SMSNotifier()log\_notifier = LogNotifier() \# Suscribir observers al sistema de pagospayment\_system.attach(email\_notifier)payment\_system.attach(sms\_notifier)payment\_system.attach(log\_notifier) \# Procesar un pagopayment\_system.process\_payment(100, "Tarjeta de Crédito") \# Desuscribir un observerpayment\_system.detach(sms\_notifier) \# Procesar otro pagopayment\_system.process\_payment(200, "PayPal")``` \### Salida Esperada \*\*Primer pago (todos los observers suscritos):\*\*```Procesando pago de 100 usando Tarjeta de Crédito.EmailNotifier: Enviando email con el mensaje: 'Pago de 100 procesado con Tarjeta de Crédito.'SMSNotifier: Enviando SMS con el mensaje: 'Pago de 100 procesado con Tarjeta de Crédito.'LogNotifier: Registrando en el log: 'Pago de 100 procesado con Tarjeta de Crédito.'``` \*\*Segundo pago (SMSNotifier desuscrito):\*\*```Procesando pago de 200 usando PayPal.EmailNotifier: Enviando email con el mensaje: 'Pago de 200 procesado con PayPal.'LogNotifier: Registrando en el log: 'Pago de 200 procesado con PayPal.'``` \### Ventajas del Patrón Observer 1\. \*\*Desacoplamiento\*\*: Los *\*subjects\** no necesitan conocer los detalles de implementación de los *\*observers\**.2. \*\*Flexibilidad\*\*: Puedes añadir o eliminar *\*observers\** en tiempo de ejecución.3. \*\*Reutilización\*\*: Los *\*observers\** pueden ser reutilizados en diferentes *\*subjects\**. \### Aplicaciones Reales 1\. \*\*Interfaces de usuario\*\*: Notificación de cambios en un modelo a vistas o controladores.2. \*\*Sistemas de eventos\*\*: Como el patrón *\*pub-sub\** en sistemas de mensajería.3. \*\*Notificaciones en tiempo real\*\*: Servicios como websockets o push notifications. \### Conclusión El \*\*Patrón Observer\*\* es una solución robusta para implementar sistemas donde un objeto central (como un sistema de pagos) necesita informar a otros objetos sobre sus cambios de estado. Su implementación en Python es simple y aprovecha características como listas dinámicas para gestionar observadores de manera eficiente.
En mi proyecto de bot de trading, uso un WebsocketManager que gestiona las conexiones las suscripciones de los websockets así como creación y eliminación de los mismos y las suscripciones a los streams. La estrategia usa estos para notificar por consolar y por mensaje de telegram. Este escenario es factible para este patrón, me queda la duda? uso colas asíncronas que van guardando los mensajes en la cola y la estrategia las va analizando