Programación reactiva

La programación reactiva es un paradigma de programación que se ocupa de los flujos de datos y la propagación del cambio. Significa que cuando un componente emite un flujo de datos, el cambio se propagará a otros componentes mediante la biblioteca de programación reactiva. La propagación del cambio continuará hasta que llegue al receptor final. La diferencia entre la programación impulsada por eventos y la reactiva es que la programación impulsada por eventos gira en torno a eventos y la programación reactiva gira en torno a los datos.

ReactiveX o RX para programación reactiva

ReactiveX o Raective Extension es la implementación más famosa de programación reactiva. El funcionamiento de ReactiveX depende de las siguientes dos clases:

Clase observable

Esta clase es la fuente de flujo de datos o eventos y empaqueta los datos entrantes para que los datos se puedan pasar de un hilo a otro. No proporcionará datos hasta que algún observador se suscriba.

Clase de observador

Esta clase consume el flujo de datos emitido por observable. Puede haber varios observadores con observables y cada observador recibirá cada elemento de datos que se emita. El observador puede recibir tres tipos de eventos suscribiéndose a observables:

on_next() event - Implica que hay un elemento en el flujo de datos.
on_completed() event - Implica el fin de la emisión y no vienen más artículos.
on_error() event - También implica fin de emisión pero en caso de que se arroje un error por observable.

RxPY - Módulo Python para programación reactiva

RxPY es un módulo de Python que se puede utilizar para programación reactiva. Necesitamos asegurarnos de que el módulo esté instalado. El siguiente comando se puede utilizar para instalar el módulo RxPY:

pip install RxPY

Ejemplo

A continuación se muestra un script de Python, que usa RxPY módulo y sus clases Observable y Observe forprogramación reactiva. Básicamente hay dos clases:

get_strings() - para obtener las cadenas del observador.
PrintObserver()- para imprimir las cadenas de observador. Utiliza los tres eventos de la clase de observador. También usa la clase subscribe ().

from rx import Observable, Observer
def get_strings(observer):
   observer.on_next("Ram")
   observer.on_next("Mohan")
   observer.on_next("Shyam")
      observer.on_completed()
class PrintObserver(Observer):
   def on_next(self, value):
      print("Received {0}".format(value))
   def on_completed(self):
   print("Finished")
   def on_error(self, error):
      print("Error: {0}".format(error))
source = Observable.create(get_strings)
source.subscribe(PrintObserver())

Salida

Received Ram
Received Mohan
Received Shyam
Finished

Biblioteca PyFunctional para programación reactiva

PyFunctionales otra biblioteca de Python que se puede usar para programación reactiva. Nos permite crear programas funcionales utilizando el lenguaje de programación Python. Es útil porque nos permite crear canalizaciones de datos utilizando operadores funcionales encadenados.

Diferencia entre RxPY y PyFunctional

Ambas bibliotecas se utilizan para programación reactiva y manejan el flujo de manera similar, pero la principal diferencia entre ambas depende del manejo de los datos. RxPY maneja datos y eventos en el sistema mientras PyFunctional se centra en la transformación de datos utilizando paradigmas de programación funcional.

Instalación del módulo PyFunctional

Necesitamos instalar este módulo antes de usarlo. Se puede instalar con la ayuda del comando pip de la siguiente manera:

pip install pyfunctional

Ejemplo

El siguiente ejemplo utiliza the PyFunctional módulo y su seqclase que actúa como el objeto de flujo con el que podemos iterar y manipular. En este programa, mapea la secuencia usando la función lamda que duplica cada valor, luego filtra el valor donde x es mayor que 4 y finalmente reduce la secuencia a una suma de todos los valores restantes.

from functional import seq

result = seq(1,2,3).map(lambda x: x*2).filter(lambda x: x > 4).reduce(lambda x, y: x + y)

print ("Result: {}".format(result))

Salida

Result: 6