Pyspark Par RDD - Transformaciones

En Python, Pyspark es un módulo de chispa utilizado para proporcionar un tipo de procesamiento similar como Spark.

RDD significa conjuntos de datos distribuidos resilientes. Podemos llamar a RDD una estructura de datos fundamental en Apache Spark. Par de RDD almacena los elementos/valores en forma de pares de valores clave. Almacenará el par de valores clave en el formato (clave, valor).

Necesitamos importar RDD del Pyspark.módulo RDD.

Entonces, en Pyspark, podemos usar el método Parallelize () para crear un RDD,.

Sintaxis:

Spark_app.sparkcontext.Paralelizar (datos)

Dónde,

Los datos pueden ser un dimensional (datos lineales) o dos dimensionales (datos de columna de fila).

Transformaciones RDD:

Una transformación RDD es una operación que se aplica a un par RDD para crear nuevos datos del par RDD existente. Usando transformaciones, podemos filtrar el par RDD aplicando algunas transformaciones.

Veamos las transformaciones que se realizan en el par RDD dada.

Los discutiremos uno por uno.

Groupbykey

GroupByKey se usa para realizar la transformación en un par RDD agrupando los valores basados ​​en la clave. Colocará todos los valores agrupados en una lista seguido de la clave.

Sintaxis:

parrdd_data.GroupByKey ()

Usaremos un bucle for para iterar claves y valores y colocaremos los valores dentro de una lista utilizando la función list ().

Ejemplo:

En este ejemplo, creamos un par RDD - Sujets_Rating y realizamos la transformación GroupByKey () a los valores de grupo con respecto a la clave. Entonces usamos un bucle para iterar claves y valores, y finalmente, mostramos cada clave y grupo de valores.

#Importa el módulo Pyspark
importar pyspark
#Import Sparksession para crear una sesión
de Pyspark.SQL Import Sparksession
# Importar RDD de Pyspark.RDD
de Pyspark.RDD import rdd
#cree una aplicación llamada Linuxhint
Spark_app = Sparksession.constructor.AppName ('Linuxhint').getorcreate ()
# Crear 6 - pares de asignatura y calificación
Sujets_rating = Spark_App.sparkcontext.Paralelize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply GroupByKey () Transformación en el par temas_rating de arriba rdd
diccionario_rdd = temas_rating.GroupByKey ().recolectar()
#get las claves y todos los valores WRT a las teclas del diccionario anterior RDD
Para claves, valores en diccionario_rdd:
imprimir (claves, "->", lista (valores))

Producción:

Python -> [4, 3]
JavaScript -> [2, 4]
Linux -> [5]
C# -> [4]

En el par de sujetos de arriba RDD, hay dos valores asociados con Key-Python y Key-JavaScript y solo un valor asociado con Linux y C#.

Bicicleta de deporte

SortByKey se usa para realizar la transformación en un par RDD devolviendo un nuevo par RDD en orden ascendente basado en la clave. Entonces, esta transformación ordenará los elementos en el par rdd por clave.

Sintaxis:

parrdd_data.sortByKey ()

Ejemplo:

En este ejemplo, creamos un par RDD - Sujets_Rating y realizamos la transformación SortByKey () para devolver los valores ordenados basados ​​en la acción Key y Applied Collect () para obtener el par ordenado RDD.

#Importa el módulo Pyspark
importar pyspark
#Import Sparksession para crear una sesión
de Pyspark.SQL Import Sparksession
# Importar RDD de Pyspark.RDD
de Pyspark.RDD import rdd
#cree una aplicación llamada Linuxhint
Spark_app = Sparksession.constructor.AppName ('Linuxhint').getorcreate ()
# Crear 6 - pares de asignatura y calificación
Sujets_rating = Spark_App.sparkcontext.Paralelize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply SortByKey () Transformación en el asunto anterior_rating para ordenar las claves en orden ascendente
imprimir (temas_rating.sortByKey ().recolectar())
.

Producción:

[('' C#', 4), (' JavaScript ', 2), (' JavaScript ', 4), (' Linux ', 5), (' Python ', 4), (' Python ', 3)]]

Podemos ver que el nuevo par clasificado RDD se devuelve mediante la clasificación basada en la clave en el par real RDD - SUMPERS_RATING.

REDUCTYKEY

ReduceKey se usa para realizar la transformación en un par RDD procesando los datos paralelista para combinar los valores con claves similares. Utilizó algunas funciones como lambda () para combinar los valores basados ​​en la clave realizando alguna operación en la función.

Sintaxis:

parrdd_data.REDUCTYKEY (función lambda)

Función lambda:

Lambda Element1, Element2: operación

Ejemplo:

En este ejemplo, creamos un par RDD - SUMPLACIONES_RATING y realizamos la transformación RedbyKey () para realizar

1. Suma de valores similares con respecto a la clave
2. Diferencia de valores similares con respecto a la clave
3. Multiplicación de valores similares con respecto a la clave
4. División de valores similares con respecto a la clave

Finalmente, podemos usar Acción Collect () para mostrar cada par transformado RDD.

#Importa el módulo Pyspark
importar pyspark
#Import Sparksession para crear una sesión
de Pyspark.SQL Import Sparksession
# Importar RDD de Pyspark.RDD
de Pyspark.RDD import rdd
#cree una aplicación llamada Linuxhint
Spark_app = Sparksession.constructor.AppName ('Linuxhint').getorcreate ()
# Crear 6 - pares de asignatura y calificación
Sujets_rating = Spark_App.sparkcontext.Paralelize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply RededByKey () Transformación en el asunto anterior_rating para reducir las claves agregando valores con claves similares
imprimir (temas_rating.REDUCTYKEY (Lambda Element1, Element2: Element1 + Element2).recolectar())
#Apply RededByKey () Transformación en el asunto anterior_ratación para reducir las claves restando valores de claves similares
imprimir (temas_rating.REDUCTYKEY (Lambda Element1, Element2: Element1 - Element2).recolectar())
#Apply RededByKey () Transformación en el asunto anterior_ratación para reducir las claves multiplicando valores con claves similares
imprimir (temas_rating.REDUCTYKEY (Lambda Element1, Element2: Element1 * Element2).recolectar())
#Apply RededByKey () Transformación en el asunto anterior_ratación para reducir las claves dividiendo valores con claves similares
imprimir (temas_rating.REDUCTYKEY (Lambda Element1, Element2: Element1 / Element2).recolectar())

Producción:

[('Python', 7), ('JavaScript', 6), ('Linux', 5), ('C#', 4)]
[('Python', 1), ('JavaScript', -2), ('Linux', 5), ('C#', 4)]
[('Python', 12), ('JavaScript', 8), ('Linux', 5), ('C#', 4)]
[('Python', 1.333333333333333333), ('javascript', 0.5), ('Linux', 5), ('C#', 4)]
Para Key-Python: los valores son 4 y 3
La suma: 4+3 = 7
La diferencia es: 4-3 = 1
La multiplicación: 4*3 = 12
La división es: 4/3 = 1.3333
Para Key-JavaScript: los valores son 2 y 4
La suma: 2+4 = 6
La diferencia es: 2-4 = -1
La multiplicación: 2*4 = 8
La división es: 2/4 = 0.5

Para Key-Linux y C#: solo hay un valor para cada uno, por lo que todas las operaciones resultantes son las mismas I.mi.

Conclusión

De este artículo de par de RDD, vimos lo que es la transformación y cómo aplicar las transformaciones de par rdd. Hay tres transformaciones que discutimos: GroupByKey () se usa para combinar todos los valores basados ​​en la clave, SortByKey () devuelve un nuevo par RDD clasificando el par RDD basado en claves en orden ascendente y reducción de la () combinará valores con respecto a clave realizando alguna operación utilizando funciones anónimas como la función lambda.