RxPy - Beispiele

In diesem Kapitel werden wir die folgenden Themen im Detail diskutieren -

Grundlegendes Beispiel, das die Arbeitsweise von Observable, Operatoren und das Abonnieren des Beobachters zeigt.
Unterschied zwischen beobachtbar und Subjekt.
Kalte und heiße Observable verstehen.

Im Folgenden finden Sie ein grundlegendes Beispiel für die Arbeitsweise von Observable, Operatoren und Abonnenten des Beobachters.

Beispiel

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!"),
)

Hier ist ein sehr einfaches Beispiel, in dem ich Benutzerdaten von dieser URL erhalte -

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

Filtern Sie die Daten, um die Namen zu erhalten, die mit "C" beginnen, und verwenden Sie später die Karte, um nur die Namen zurückzugeben. Hier ist die Ausgabe für das gleiche -

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

Unterschied zwischen beobachtbar und Subjekt

In diesem Beispiel sehen wir den Unterschied zwischen einem beobachtbaren und einem Subjekt.

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

Ausgabe

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

Im obigen Beispiel erhalten Sie jedes Mal, wenn Sie das Observable abonnieren, neue Werte.

Betreff Beispiel

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)

Ausgabe

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

Wenn Sie sehen, dass die Werte gemeinsam genutzt werden, verwenden beide Teilnehmer den Betreff.

Grundlegendes zu kalten und heißen Observablen

Ein Observable wird klassifiziert als

Kalte Observable
Heiße Observablen

Der Unterschied bei den Observablen wird bemerkt, wenn mehrere Abonnenten abonnieren.

Kalte Observable

Kalte Observablen sind beobachtbar, die ausgeführt werden, und rendern Daten jedes Mal, wenn sie abonniert werden. Wenn es abonniert ist, wird das Observable ausgeführt und die neuen Werte werden angegeben.

Das folgende Beispiel vermittelt das Verständnis von beobachtbarer Kälte.

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

Ausgabe

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

Im obigen Beispiel werden jedes Mal, wenn Sie das Observable abonnieren, das Observable ausgeführt und Werte ausgegeben. Die Werte können auch von Teilnehmer zu Teilnehmer unterschiedlich sein, wie im obigen Beispiel gezeigt.

Heiße Observablen

Im Falle von Hot Observable geben sie die Werte aus, wenn sie bereit sind, und warten nicht immer auf ein Abonnement. Wenn die Werte ausgegeben werden, erhalten alle Teilnehmer den gleichen Wert.

Sie können Hot Observable verwenden, wenn Sie möchten, dass Werte ausgegeben werden, wenn das Observable bereit ist, oder wenn Sie allen Ihren Abonnenten dieselben Werte mitteilen möchten.

Ein Beispiel für Hot Observable sind Subject- und Connectable-Operatoren.

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)

Ausgabe

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

Wenn Sie sehen, wird derselbe Wert zwischen den Abonnenten geteilt. Sie können dasselbe mit dem connectable-Observable-Operator Publish () erreichen.