RxPy - Exemples

Dans ce chapitre, nous aborderons en détail les sujets suivants -

• Exemple de base montrant le fonctionnement d'observable, d'opérateurs et d'abonnement à l'observateur.
• Différence entre observable et sujet.
• Comprendre les observables froids et chauds.

Vous trouverez ci-dessous un exemple de base montrant le fonctionnement de l'observable, des opérateurs et l'abonnement à l'observateur.

Exemple

test.py

import requests
import rx
import json
from rx import operators as ops
def filternames(x):
   if (x["name"].startswith("C")):
      return x["name"]
   else :
      return ""
content = requests.get('https://jsonplaceholder.typicode.com/users')
y = json.loads(content.text)
source = rx.from_(y)
case1 = source.pipe(
   ops.filter(lambda c: filternames(c)),
   ops.map(lambda a:a["name"])
)
case1.subscribe(
   on_next = lambda i: print("Got - {0}".format(i)), 8. RxPy — Examples
   on_error = lambda e: print("Error : {0}".format(e)),
   on_completed = lambda: print("Job Done!"),
)

Voici un exemple très simple, dans lequel j'obtiens des données utilisateur à partir de cette URL -

https://jsonplaceholder.typicode.com/users.

Filtrer les données, pour donner les noms commençant par "C", et plus tard utiliser la carte pour renvoyer les noms uniquement. Voici la sortie pour le même -

E:\pyrx\examples>python test.py
Got - Clementine Bauch
Got - Chelsey Dietrich
Got - Clementina DuBuque
Job Done!

Différence entre observable et sujet

Dans cet exemple, nous verrons la différence entre un observable et un sujet.

from rx import of, operators as op
import random
test1 = of(1,2,3,4,5)
sub1 = test1.pipe(
   op.map(lambda a : a+random.random())
)
print("From first subscriber")
subscriber1 = sub1.subscribe(lambda i: print("From sub1 {0}".format(i)))
print("From second subscriber")
subscriber2 = sub1.subscribe(lambda i: print("From sub2 {0}".format(i)))

Production

E:\pyrx>python testrx.py
From first subscriber
From sub1 1.610450821095726
From sub1 2.9567564032037335
From sub1 3.933217537811936
From sub1 4.82444905626622
From sub1 5.929414892567188
From second subscriber
From sub2 1.8573813517529874
From sub2 2.902433239469483
From sub2 3.2289868093016825
From sub2 4.050413890694411
From sub2 5.226515068012821

Dans l'exemple ci-dessus, chaque fois que vous vous abonnez à l'observable, il vous donnera de nouvelles valeurs.

Exemple de sujet

from rx import of, operators as op
import random
from rx.subject import Subject
subject_test = Subject()
subject_test.subscribe(
   lambda x: print("From sub1 {0}".format(x))
)
subject_test.subscribe(
   lambda x: print("From sub2 {0}".format(x))
)
test1 = of(1,2,3,4,5)
sub1 = test1.pipe(
   op.map(lambda a : a+random.random())
)
subscriber = sub1.subscribe(subject_test)

Production

E:\pyrx>python testrx.py
From sub1 1.1789422863284509
From sub2 1.1789422863284509
From sub1 2.5525627903260153
From sub2 2.5525627903260153
From sub1 3.4191549324778325
From sub2 3.4191549324778325
From sub1 4.644042420199624
From sub2 4.644042420199624
From sub1 5.079896897489065
From sub2 5.079896897489065

Si vous voyez que les valeurs sont partagées, entre les deux abonnés utilisant le sujet.

Comprendre les observables froids et chauds

Un observable est classé comme

• Observables froids
• Observables chauds

La différence d'observables sera remarquée lorsque plusieurs abonnés s'abonnent.

Observables froids

Les observables froids sont des observables qui sont exécutés et restituent des données à chaque fois qu'il est abonné. Lorsqu'elle est souscrite, l'observable est exécutée et les nouvelles valeurs sont données.

L'exemple suivant donne la compréhension du froid observable.

from rx import of, operators as op
import random
test1 = of(1,2,3,4,5)
sub1 = test1.pipe(
   op.map(lambda a : a+random.random())
)
print("From first subscriber")
subscriber1 = sub1.subscribe(lambda i: print("From sub1 {0}".format(i)))
print("From second subscriber")
subscriber2 = sub1.subscribe(lambda i: print("From sub2 {0}".format(i)))

Production

E:\pyrx>python testrx.py
From first subscriber
From sub1 1.610450821095726
From sub1 2.9567564032037335
From sub1 3.933217537811936
From sub1 4.82444905626622
From sub1 5.929414892567188
From second subscriber
From sub2 1.8573813517529874
From sub2 2.902433239469483
From sub2 3.2289868093016825
From sub2 4.050413890694411
From sub2 5.226515068012821

Dans l'exemple ci-dessus, chaque fois que vous vous abonnez à l'observable, il exécutera l'observable et émettra des valeurs. Les valeurs peuvent également différer d'un abonné à un autre, comme illustré dans l'exemple ci-dessus.

Observables chauds

Dans le cas des observables à chaud, ils émettront les valeurs quand ils seront prêts et n'attendront pas toujours un abonnement. Lorsque les valeurs sont émises, tous les abonnés recevront la même valeur.

Vous pouvez utiliser l'observable à chaud lorsque vous souhaitez que des valeurs soient émises lorsque l'observable est prête ou que vous souhaitez partager les mêmes valeurs avec tous vos abonnés.

Un exemple d'observable à chaud est les opérateurs Subject et connectable.

from rx import of, operators as op
import random
from rx.subject import Subject
subject_test = Subject()
subject_test.subscribe(
   lambda x: print("From sub1 {0}".format(x))
)
subject_test.subscribe(
   lambda x: print("From sub2 {0}".format(x))
)
test1 = of(1,2,3,4,5)
sub1 = test1.pipe(
   op.map(lambda a : a+random.random())
)
subscriber = sub1.subscribe(subject_test)

Production

E:\pyrx>python testrx.py
From sub1 1.1789422863284509
From sub2 1.1789422863284509
From sub1 2.5525627903260153
From sub2 2.5525627903260153
From sub1 3.4191549324778325
From sub2 3.4191549324778325
From sub1 4.644042420199624
From sub2 4.644042420199624
From sub1 5.079896897489065
From sub2 5.079896897489065

Si vous voyez, la même valeur est partagée entre les abonnés. Vous pouvez obtenir la même chose en utilisant l'opérateur observable connectable publish ().