RxPY - Overview

This chapter explains what is reactive programming, what is RxPY, its operators, features, advantages and disadvantage.

What is Reactive Programming?

Reactive programming is a programming paradigm, that deals with data flow and the propagation of change. It means that, when a data flow is emitted by one component, the change will be propagated to other components by a reactive programming pbrary. The propagation of change will continue until it reaches the final receiver.

By using RxPY, you have good control on the asynchronous data streams, for example, a request made to URL can be traced by using observable, and use the observer to psten to when the request is complete for response or error.

RxPY offers you to handle asynchronous data streams using Observables, query the data streams using Operators i.e. filter, sum, concat, map and also make use of concurrency for the data streams using Schedulers. Creating an Observable, gives an observer object with on_next(v), on_error(e) and on_completed() methods, that needs to be subscribed so that we get a notification when an event occurs.

The Observable can be queried using multiple operators in a chain format by using the pipe operator.

RxPY offers operators in various categories pke:−

Mathematical operators

Transformation operators

Filtering operators

Error handpng operators

Utipty operators

Conditional operators

Creation operators

Connectable operators

These operators are explained in detail in this tutorial.

What is RxPy?

RxPY is defined as a pbrary for composing asynchronous and event-based programs using observable collections and pipable query operators in Python as per the official website of RxPy, which is https://rxpy.readthedocs.io/en/latest/.

RxPY is a python pbrary to support Reactive Programming. RxPy stands for Reactive Extensions for Python. It s a pbrary that uses observables to work with reactive programming that deals with asynchronous data calls, callbacks and event−based programs.

Features of RxPy

In RxPy, following concepts take care of handpng the asynchronous task −

Observable

An observable is a function that creates an observer and attaches it to the source having data streams that are expected from, for example, Tweets, computer−related events, etc.

Observer

It is an object with on_next(), on_error() and on_completed() methods, that will get called when there is interaction with the observable i.e. the source interacts for an example incoming Tweets, etc.

Subscription

When the observable is created, to execute the observable we need to subscribe to it.

Operators

An operator is a pure function that takes in observable as input and the output is also an observable. You can use multiple operators on an observable data by using the pipe operator.

Subject

A subject is an observable sequence as well as an observer that can multicast, i.e. talk to many observers that have subscribed. The subject is a cold observable, i.e. the values will be shared between the observers that have been subscribed.

Schedulers

One important feature of RxPy is concurrency i.e. to allow the task to execute in parallel. To make that happen RxPy has two operators subscribe_on() and observe_on() that works with schedulers and will decide the execution of the subscribed task.

Advantages of using RxPY

The following are the advantages of RxPy −

RxPY is an awesome pbrary when it comes to the handpng of async data streams and events. RxPY uses observables to work with reactive programming that deals with asynchronous data calls, callbacks and event-based programs.

RxPY offers a huge collection of operators in mathematical, transformation, filtering, utipty, conditional, error handpng, join categories that makes pfe easy when used with reactive programming.

Concurrency i.e. working of multiple tasks together is achieved using schedulers in RxPY.

The performance is improved using RxPY as handpng of async task and parallel processing is made easy.

Disadvantage of using RxPY

Debugging the code with observables is a pttle difficult.