Programação reativa

A programação reativa é um paradigma de programação que lida com fluxos de dados e a propagação da mudança. Isso significa que quando um fluxo de dados é emitido por um componente, a mudança será propagada para outros componentes pela biblioteca de programação reativa. A propagação da mudança continuará até que alcance o receptor final. A diferença entre programação orientada a eventos e reativa é que a programação orientada a eventos gira em torno de eventos e a programação reativa gira em torno de dados.

ReactiveX ou RX para programação reativa

ReactiveX ou Raective Extension é a implementação mais famosa de programação reativa. O funcionamento do ReactiveX depende das duas classes a seguir -

Classe observável

Essa classe é a fonte do fluxo de dados ou eventos e empacota os dados de entrada para que os dados possam ser passados de um thread para outro. Ele não fornecerá dados até que algum observador se inscreva nele.

Classe observador

Esta classe consome o fluxo de dados emitido por observable. Pode haver vários observadores com observáveis e cada observador receberá cada item de dados que é emitido. O observador pode receber três tipos de eventos ao se inscrever em observáveis -

on_next() event - Implica que existe um elemento no fluxo de dados.
on_completed() event - Implica o fim da emissão e não há mais itens chegando.
on_error() event - Implica também no fim da emissão, mas no caso de ocorrer um erro por observable.

RxPY - Módulo Python para Programação Reativa

RxPY é um módulo Python que pode ser usado para programação reativa. Precisamos garantir que o módulo esteja instalado. O seguinte comando pode ser usado para instalar o módulo RxPY -

pip install RxPY

Exemplo

A seguir está um script Python, que usa RxPY módulo e suas classes Observable e Observe forprogramação reativa. Existem basicamente duas classes -

get_strings() - para obter as strings do observador.
PrintObserver()- para imprimir as strings do observador. Ele usa todos os três eventos da classe observador. Ele também usa a 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())

Resultado

Received Ram
Received Mohan
Received Shyam
Finished

Biblioteca PyFunctional para programação reativa

PyFunctionalé outra biblioteca Python que pode ser usada para programação reativa. Ele nos permite criar programas funcionais usando a linguagem de programação Python. É útil porque nos permite criar pipelines de dados usando operadores funcionais encadeados.

Diferença entre RxPY e PyFunctional

Ambas as bibliotecas são usadas para programação reativa e tratam o fluxo de maneira semelhante, mas a principal diferença entre as duas depende da manipulação de dados. RxPY lida com dados e eventos no sistema enquanto PyFunctional está focado na transformação de dados usando paradigmas de programação funcional.

Instalando Módulo PyFunctional

Precisamos instalar este módulo antes de usá-lo. Ele pode ser instalado com a ajuda do comando pip da seguinte forma -

pip install pyfunctional

Exemplo

O exemplo a seguir usa the PyFunctional módulo e seu seqclasse que atua como o objeto de fluxo com o qual podemos iterar e manipular. Neste programa, ele mapeia a sequência usando a função lamda que dobra todos os valores, então filtra o valor onde x é maior que 4 e finalmente reduz a sequência em uma soma de todos os 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))

Resultado

Result: 6

↰ Previous page