Pyspark -par RDD - Transformasjoner

I Python er Pyspark en gnistmodul som brukes til å gi en lignende type prosessering som Spark.

RDD står for spenstige distribuerte datasett. Vi kan kalle RDD en grunnleggende datastruktur i Apache Spark. Par RDD lagrer elementene/verdiene i form av nøkkelverdipar. Det vil lagre nøkkelverdiparet i formatet (nøkkel, verdi).

Vi må importere RDD fra Pyspark.RDD -modul.

Så i Pyspark kan vi bruke parallelliseringsmetoden () for å lage en RDD,.

Syntaks:

Spark_app.SparkContext.parallellisere (data)

Hvor,

Data kan være en endimensjonal (lineære data) eller to dimensjonale (rad-kolonne data).

RDD -transformasjoner:

En transformasjon RDD er en operasjon som brukes på et par RDD for å lage nye data fra det eksisterende paret RDD. Ved hjelp av transformasjoner kan vi filtrere paret RDD ved å bruke noen transformasjoner.

La oss se transformasjonene som utføres på det gitte paret RDD.

Vi vil diskutere dem en etter en.

GroupByKey

GroupByKey brukes til å utføre transformasjon på et par RDD ved å gruppere verdiene basert på nøkkel. Den vil plassere alle grupperte verdier i en liste etterfulgt av nøkkelen.

Syntaks:

parrdd_data.GroupByKey ()

Vi vil bruke en for loop for å iterere nøkler og verdier og plassere verdiene i en liste ved hjelp av listen () -funksjonen.

Eksempel:

I dette eksemplet opprettet vi et par RDD - emner_rering og utførte groupByKey () transformasjon til gruppeverdier med hensyn til nøkkel. Så vi brukte en sløyfe til å iterere nøkler og verdier, og til slutt viste vi hver nøkkel- og verdigruppe.

#import Pyspark -modulen
Importer pyspark
#import SparkSession for å lage en økt
Fra Pyspark.SQL Import SparkSession
# Importer RDD fra Pyspark.RDD
Fra Pyspark.RDD Import RDD
#Create en app som heter Linuxhint
Spark_app = SparkSession.bygger.AppName ('Linuxhint').getorCreate ()
# Opprett 6 - Fag- og rangeringspar
emner_rating = spark_app.SparkContext.Parallellize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply groupByKey () Transformasjon på de ovennevnte emne_rating -paret RDD
Dictionary_RDD = emner_rering.GroupByKey ().samle inn()
#Få nøklene og alle verdiene WRT til nøkler fra ovennevnte Dictionary RDD
For nøkler, verdier i Dictionary_rdd:
Print (Keys, "->", Liste (verdier))

Produksjon:

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

I de ovennevnte emne_reringsparet RDD er det to verdier assosiert med nøkkel-python og nøkkel-javascript, og bare en verdi assosiert med Linux og C#.

Sportsbike

Sortbykey brukes til å utføre transformasjon på et par RDD ved å returnere et nytt par RDD i stigende rekkefølge basert på nøkkel. Så denne transformasjonen vil sortere elementene i par RDD etter nøkkel.

Syntaks:

parrdd_data.sortbykey ()

Eksempel:

I dette eksemplet opprettet vi et par RDD - emner_rering og utførte sortbykey () transformasjon for å returnere sorterte verdier basert på nøkkel og anvendt samle () handling for å få det sorterte paret RDD.

#import Pyspark -modulen
Importer pyspark
#import SparkSession for å lage en økt
Fra Pyspark.SQL Import SparkSession
# Importer RDD fra Pyspark.RDD
Fra Pyspark.RDD Import RDD
#Create en app som heter Linuxhint
Spark_app = SparkSession.bygger.AppName ('Linuxhint').getorCreate ()
# Opprett 6 - Fag- og rangeringspar
emner_rating = spark_app.SparkContext.Parallellize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply sortBykey () transformasjon på ovennevnte emner_rering for å sortere tastene i stigende rekkefølge
skriv ut (emner_rering.sortbykey ().samle inn())
.

Produksjon:

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

Vi kan se at det nye sorterte paret RDD blir returnert ved sortering basert på nøkkelen i selve paret RDD - Emner_rering.

Reduserbykey

ReduceByKey brukes til å utføre transformasjon på et par RDD ved å behandle dataene parallelly for å kombinere verdiene med lignende nøkler. Den brukte noen funksjoner som lambda () for å kombinere verdiene basert på nøkkelen ved å utføre en eller annen operasjon i funksjonen.

Syntaks:

parrdd_data.ReduceByKey (Lambda -funksjon)

Lambda -funksjon:

Lambda Element1, Element2: Operasjon

Eksempel:

I dette eksemplet opprettet vi et par RDD - emner_rering og utførte ReductByKey () transformasjon for å utføre

1. Sum av lignende verdier med hensyn til nøkkel
2. Forskjell på lignende verdier med hensyn til nøkkel
3. Multiplikasjon av lignende verdier med hensyn til nøkkel
4. Deling av lignende verdier med hensyn til nøkkel

Endelig kan vi bruke Collect () handling for å vise hvert transformert par RDD.

#import Pyspark -modulen
Importer pyspark
#import SparkSession for å lage en økt
Fra Pyspark.SQL Import SparkSession
# Importer RDD fra Pyspark.RDD
Fra Pyspark.RDD Import RDD
#Create en app som heter Linuxhint
Spark_app = SparkSession.bygger.AppName ('Linuxhint').getorCreate ()
# Opprett 6 - Fag- og rangeringspar
emner_rating = spark_app.SparkContext.Parallellize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C#', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply redusere bykey () transformasjon på ovennevnte emner_rering for å redusere nøkler ved å legge til verdier med lignende taster
skriv ut (emner_rering.ReduceByKey (Lambda Element1, Element2: Element1 + Element2).samle inn())
#Apply redusere transformasjon av bytykey () på de ovennevnte emner_rering for å redusere nøkler ved å trekke fra verdier fra lignende nøkler
skriv ut (emner_rering.ReduceByKey (Lambda Element1, Element2: Element1 - Element2).samle inn())
#Apply redusere transformasjon av bykey () på de ovennevnte emner_rering for å redusere nøkler ved å multiplisere verdier med lignende taster
skriv ut (emner_rering.ReduceByKey (Lambda Element1, Element2: Element1 * Element2).samle inn())
#Apply redusere transformasjon av bykey () på ovennevnte emner_rering for å redusere nøkler ved å dele verdier med lignende nøkler
skriv ut (emner_rering.ReduceByKey (Lambda Element1, Element2: Element1 / Element2).samle inn())

Produksjon:

[('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)]
For nøkkel-python: Verdiene er 4 og 3
Summen: 4+3 = 7
Forskjellen er: 4-3 = 1
Multiplikasjonen: 4*3 = 12
Divisjonen er: 4/3 = 1.3333
For nøkkel-javascript: Verdiene er 2 og 4
Summen: 2+4 = 6
Forskjellen er: 2-4 = -1
Multiplikasjonen: 2*4 = 8
Divisjonen er: 2/4 = 0.5

For nøkkel-linux og c#: Det er bare en verdi for hver, så alle operasjoner som resulterer er de samme i.e.

Konklusjon

Fra denne paret RDD -artikkelen så vi hva som er transformasjon og hvordan du bruker par RDD -transformasjoner. Det er tre transformasjoner som vi diskuterte: GroupByKey () brukes til å kombinere alle verdier basert på nøkkel, sortBykey () returnerer et nytt par RDD ved å sortere paret RDD basert på nøkler i stigende rekkefølge og redusere Bykey () vil kombinere verdier med hensyn til Nøkkel ved å utføre en eller annen operasjon ved hjelp av anonyme funksjoner som lambda -funksjon.