- RxPY Tutorial
- RxPY - Home
- RxPY - Overview
- RxPY - Environment Setup
- RxPY - Latest Release Updates
- RxPY - Working with Observables
- RxPY- Operators
- RxPY - Working With Subject
- RxPY - Concurrency Using Scheduler
- RxPY - Examples
- RxPY Useful Resources
- RxPY - Quick Guide
- RxPY - Useful Resources
- RxPY - Discussion
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 library. 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 listen 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 like:−
Mathematical operators
Transformation operators
Filtering operators
Error handling operators
Utility operators
Conditional operators
Creation operators
Connectable operators
These operators are explained in detail in this tutorial.
What is RxPy?
RxPY is defined as a library 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 library to support Reactive Programming. RxPy stands for Reactive Extensions for Python. It's a library 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 handling 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 library when it comes to the handling 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, utility, conditional, error handling, join categories that makes life 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 handling of async task and parallel processing is made easy.
Disadvantage of using RxPY
Debugging the code with observables is a little difficult.