Programmazione reattiva

La programmazione reattiva è un paradigma di programmazione che si occupa dei flussi di dati e della propagazione del cambiamento. Significa che quando un flusso di dati viene emesso da un componente, la modifica verrà propagata ad altri componenti dalla libreria di programmazione reattiva. La propagazione del cambiamento continuerà fino a raggiungere il ricevitore finale. La differenza tra la programmazione guidata dagli eventi e quella reattiva è che la programmazione guidata dagli eventi ruota attorno agli eventi e la programmazione reattiva ruota attorno ai dati.

ReactiveX o RX per la programmazione reattiva

ReactiveX o Raective Extension è l'implementazione più famosa della programmazione reattiva. Il funzionamento di ReactiveX dipende dalle seguenti due classi:

Classe osservabile

Questa classe è l'origine del flusso di dati o degli eventi e racchiude i dati in arrivo in modo che i dati possano essere passati da un thread a un altro. Non fornirà dati fino a quando qualche osservatore non si iscriverà.

Classe osservatore

Questa classe consuma il flusso di dati emesso da observable. Possono esserci più osservatori con osservabile e ogni osservatore riceverà ogni elemento di dati emesso. L'osservatore può ricevere tre tipi di eventi iscrivendosi a Observable:

  • on_next() event - Implica la presenza di un elemento nel flusso di dati.

  • on_completed() event - Implica la fine dell'emissione e non sono in arrivo altri articoli.

  • on_error() event - Implica anche la fine dell'emissione, ma nel caso in cui venga generato un errore da observable.

RxPY - Modulo Python per la programmazione reattiva

RxPY è un modulo Python che può essere utilizzato per la programmazione reattiva. Dobbiamo assicurarci che il modulo sia installato. Il seguente comando può essere utilizzato per installare il modulo RxPY:

pip install RxPY

Esempio

Di seguito è riportato uno script Python, che utilizza RxPY modulo e le sue classi Observable e Observe forprogrammazione reattiva. Ci sono fondamentalmente due classi:

  • get_strings() - per ottenere le stringhe dall'osservatore.

  • PrintObserver()- per stampare le stringhe dall'osservatore. Utilizza tutti e tre gli eventi della classe dell'osservatore. Utilizza anche la classe 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())

Produzione

Received Ram
Received Mohan
Received Shyam
Finished

Libreria PyFunctional per la programmazione reattiva

PyFunctionalè un'altra libreria Python che può essere utilizzata per la programmazione reattiva. Ci consente di creare programmi funzionali utilizzando il linguaggio di programmazione Python. È utile perché ci consente di creare pipeline di dati utilizzando operatori funzionali concatenati.

Differenza tra RxPY e PyFunctional

Entrambe le librerie vengono utilizzate per la programmazione reattiva e gestiscono il flusso in modo simile, ma la differenza principale tra entrambe dipende dalla gestione dei dati. RxPY gestisce i dati e gli eventi nel sistema mentre PyFunctional si concentra sulla trasformazione dei dati utilizzando paradigmi di programmazione funzionale.

Installazione del modulo PyFunctional

Abbiamo bisogno di installare questo modulo prima di usarlo. Può essere installato con l'aiuto del comando pip come segue:

pip install pyfunctional

Esempio

Il seguente esempio utilizza the PyFunctional modulo e il suo seqclasse che funge da oggetto stream con il quale possiamo iterare e manipolare. In questo programma, mappa la sequenza utilizzando la funzione lamda che raddoppia ogni valore, quindi filtra il valore dove x è maggiore di 4 e infine riduce la sequenza in una somma di tutti i valori rimanenti.

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))

Produzione

Result: 6