Pyspark Par Rdd - Transformações

Em Python, Pyspark é um módulo Spark usado para fornecer um tipo semelhante de processamento como o Spark.

RDD significa conjuntos de dados distribuídos resilientes. Podemos chamar RDD de estrutura de dados fundamental no Apache Spark. Emparelhar o RDD armazena os elementos/valores na forma de pares de valor-chave. Ele armazenará o par de valores-chave no formato (chave, valor).

Precisamos importar RDD do Pyspark.Módulo RDD.

Portanto, em Pyspark, podemos usar o método parallelize () para criar um RDD,.

Sintaxe:

Spark_App.SparkContext.paralelize (dados)

Onde,

Os dados podem ser um dimensional (dados lineares) ou bidimensional (dados da coluna de linha).

Transformações RDD:

Um RDD de transformação é uma operação que é aplicada a um par RDD para criar novos dados do par existente RDD. Usando transformações, somos capazes de filtrar o par RDD aplicando algumas transformações.

Vamos ver as transformações que são realizadas no par de pares RDD.

Vamos discuti -los um por um.

GrupoByKey

GrupoByKey é usado para executar a transformação em um par RDD, agrupando os valores com base na chave. Ele colocará todos os valores agrupados em uma lista seguida pela chave.

Sintaxe:

parrdd_data.groupByKey ()

Usaremos um loop for para iterar as chaves e valores e colocar os valores dentro de uma lista usando a função List ().

Exemplo:

Neste exemplo, criamos um par RDD - sujeitos_rating e executamos a transformação de groupByKey () em valores de grupo em relação à chave. Por isso, usamos um loop para iterar chaves e valores e, finalmente, exibimos cada chave de chave e valor.

#import o módulo Pyspark
Importar Pyspark
#Import SparkSession para criar uma sessão
de Pyspark.SQL Import SparkSession
# importar rdd do Pyspark.rdd
de Pyspark.RDD Import rdd
#Crie um aplicativo chamado Linuxhint
Spark_App = SparkSession.construtor.AppName ('Linuxhint').getorcreate ()
# Criar 6 - Pares de assunto e classificação
sujeitos_rating = spark_app.SparkContext.paralelize ([('python', 4), ('javascript', 2), ('linux', 5), ('c#', 4), ('javascript', 4), ('python', 3) ]))
#apply groupbykey () transformação no par de sujeitos acima RDD
dictionary_rdd = sujeitos_rating.groupByKey ().colecionar ()
#Get the Keys e todos os valores WRT para chaves do Dictionary RDD acima
Para chaves, valores no dictionary_rdd:
Print (Keys, "->", List (valores))

Saída:

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

No RDD de pares de sujeitos acima, há dois valores associados a Key-Python e Key-Javascript e apenas um valor associado a Linux e C#.

Sportbike

SortbyKey é usado para executar a transformação em um par RDD retornando um novo par RDD em ordem crescente com base na chave. Portanto, essa transformação classificará os elementos no par RDD por chave.

Sintaxe:

parrdd_data.SortbyKey ()

Exemplo:

Neste exemplo, criamos um par RDD - SIGNESS_RATING e executamos a transformação SortbyKey () para retornar valores classificados com base na ação de key e Applied collect () para obter o par classificado RDD.

#import o módulo Pyspark
Importar Pyspark
#Import SparkSession para criar uma sessão
de Pyspark.SQL Import SparkSession
# importar rdd do Pyspark.rdd
de Pyspark.RDD Import rdd
#Crie um aplicativo chamado Linuxhint
Spark_App = SparkSession.construtor.AppName ('Linuxhint').getorcreate ()
# Criar 6 - Pares de assunto e classificação
sujeitos_rating = spark_app.SparkContext.paralelize ([('python', 4), ('javascript', 2), ('linux', 5), ('c#', 4), ('javascript', 4), ('python', 3) ]))
#Apply SortbyKey () Transformação nos sujeitos acima
Imprimir (sujeitos_rating.SortbyKey ().colet ()))
.

Saída:

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

Podemos ver que o novo par classificado RDD é devolvido pela classificação com base na chave no par RDD real - sujeitos_rating.

ReduceByKey

ReduceByKey é usado para executar a transformação em um par RDD, processando os dados parallelly para combinar os valores com chaves semelhantes. Ele usou algumas funções como Lambda () para combinar os valores com base na chave, executando alguma operação na função.

Sintaxe:

parrdd_data.ReduceByKey (função lambda)

Função lambda:

Lambda Element1, Element2: Operação

Exemplo:

Neste exemplo, criamos um par RDD - Subjects_rating e executamos ReduceByKey () Transformação para executar

1. Soma de valores semelhantes em relação à chave
2. Diferença de valores semelhantes em relação à chave
3. Multiplicação de valores semelhantes em relação à chave
4. Divisão de valores semelhantes em relação à chave

Finalmente, podemos usar a ação colecionada () para exibir cada par transformado RDD.

#import o módulo Pyspark
Importar Pyspark
#Import SparkSession para criar uma sessão
de Pyspark.SQL Import SparkSession
# importar rdd do Pyspark.rdd
de Pyspark.RDD Import rdd
#Crie um aplicativo chamado Linuxhint
Spark_App = SparkSession.construtor.AppName ('Linuxhint').getorcreate ()
# Criar 6 - Pares de assunto e classificação
sujeitos_rating = spark_app.SparkContext.paralelize ([('python', 4), ('javascript', 2), ('linux', 5), ('c#', 4), ('javascript', 4), ('python', 3) ]))
#Apply ReduceByKey () Transformação nos sujeitos acima STEINDS_RATING para reduzir as chaves adicionando valores com teclas semelhantes
Imprimir (sujeitos_rating.ReduceByKey (Lambda Element1, Element2: Element1 + Element2).colet ()))
#Apply ReduceByKey () Transformação nos sujeitos acima STEITTS_RATING para reduzir as chaves subtraindo os valores de teclas semelhantes
Imprimir (sujeitos_rating.ReduceByKey (Lambda Element1, Element2: Element1 - Element2).colet ()))
#Apply ReduceByKey () Transformação nos sujeitos acima STEITTS_RATING para reduzir as chaves multiplicando valores com teclas semelhantes
Imprimir (sujeitos_rating.ReduceByKey (Lambda Element1, Element2: Element1 * Element2).colet ()))
#Apply ReduceByKey () Transformação nos sujeitos acima STEITTS_RATING para reduzir as chaves dividindo valores com teclas semelhantes
Imprimir (sujeitos_rating.ReduceByKey (Lambda Element1, Element2: Element1 / Element2).colet ()))

Saída:

[('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.33333333333333333), ('JavaScript', 0.5), ('Linux', 5), ('C#', 4)]
Para o Key-Python: os valores são 4 e 3
A soma: 4+3 = 7
A diferença é: 4-3 = 1
A multiplicação: 4*3 = 12
A divisão é: 4/3 = 1.3333
Para key-Javascript: os valores são 2 e 4
A soma: 2+4 = 6
A diferença é: 2-4 = -1
A multiplicação: 2*4 = 8
A divisão é: 2/4 = 0.5

Para Key-Linux e C#: Existe apenas um valor para cada um, então todas as operações resultantes são as mesmas.e.

Conclusão

A partir deste par de RDD, vimos o que é a transformação e como aplicar transformações de RDD em pares. Existem três transformações que discutimos: o groupByKey () é usado para combinar todos os valores com base em Key, SortbyKey () retorna um novo par RDD, classificando o par RDD com base em chaves em ordem crescente e ReduceByKey () combinará valores com relação a Chave ao executar alguma operação usando funções anônimas como a função lambda.