RxPy - Ejemplos

En este capítulo, discutiremos los siguientes temas en detalle:

Ejemplo básico que muestra el funcionamiento de operadores observables y suscripciones al observador.
Diferencia entre observable y sujeto.
Comprender los observables fríos y calientes.

A continuación se muestra un ejemplo básico que muestra el funcionamiento de los operadores observables y la suscripción del observador.

Ejemplo

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

Aquí hay un ejemplo muy simple, en el que obtengo datos de usuario de esta URL:

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

Filtrar los datos, para dar los nombres que comienzan con "C", y luego usar el mapa para devolver solo los nombres. Aquí está la salida para lo mismo:

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

Diferencia entre observable y sujeto

En este ejemplo, veremos la diferencia entre un observable y un sujeto.

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

Salida

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

En el ejemplo anterior, cada vez que se suscribe al observable, le dará nuevos valores.

Ejemplo de tema

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)

Salida

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 ve que los valores son compartidos, entre ambos suscriptores que usan el asunto.

Comprensión de los observables fríos y calientes

Un observable se clasifica como

Observables fríos
Observables calientes

La diferencia en los observables se notará cuando se suscriban varios suscriptores.

Observables fríos

Los observables fríos, son observables que se ejecutan y generan datos cada vez que se suscriben. Cuando se suscribe, se ejecuta el observable y se dan los valores nuevos.

El siguiente ejemplo da la comprensión del frío 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)))

Salida

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

En el ejemplo anterior, cada vez que se suscribe al observable, ejecutará los valores observables y emitidos. Los valores también pueden diferir de un suscriptor a otro, como se muestra en el ejemplo anterior.

Observables calientes

En el caso de los observables en caliente, emitirán los valores cuando estén listos y no siempre esperarán una suscripción. Cuando se emiten los valores, todos los suscriptores obtendrán el mismo valor.

Puede utilizar el observable en caliente cuando desee que los valores se emitan cuando el observable esté listo, o si desea compartir los mismos valores con todos sus suscriptores.

Un ejemplo de observable en caliente es el sujeto y los operadores conectables.

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)

Salida

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 ve, el mismo valor se comparte entre los suscriptores. Puede lograr lo mismo utilizando el operador observable conectable publish ().

↰ Previous page Next page ↱