En aquest tema, explorarem dos conceptes fonamentals en Apache Spark: les transformacions i les accions. Aquests conceptes són essencials per treballar amb RDDs (Resilient Distributed Datasets) i altres estructures de dades en Spark.

Les transformacions són operacions que es realitzen sobre un RDD per crear un nou RDD. Les transformacions són "lazy", és a dir, no s'executen immediatament. En lloc d'això, Spark construeix un pla d'execució que s'executa només quan es crida a una acció.

1. map(funció):

   • Aplica una funció a cada element de l'RDD i retorna un nou RDD amb els resultats.

   rdd = sc.parallelize([1, 2, 3, 4])
   rdd2 = rdd.map(lambda x: x * 2)
   print(rdd2.collect())  # Sortida: [2, 4, 6, 8]
   

2. filter(funció):

   • Filtra els elements de l'RDD que compleixen una condició donada.

   rdd = sc.parallelize([1, 2, 3, 4])
   rdd2 = rdd.filter(lambda x: x % 2 == 0)
   print(rdd2.collect())  # Sortida: [2, 4]
   

3. flatMap(funció):

   • Aplica una funció a cada element de l'RDD i retorna un nou RDD amb els resultats aplanats.

   rdd = sc.parallelize(["Hello World", "Apache Spark"])
   rdd2 = rdd.flatMap(lambda x: x.split(" "))
   print(rdd2.collect())  # Sortida: ['Hello', 'World', 'Apache', 'Spark']
   

4. distinct():

   • Retorna un nou RDD amb els elements únics de l'RDD original.

   rdd = sc.parallelize([1, 2, 2, 3, 3, 3])
   rdd2 = rdd.distinct()
   print(rdd2.collect())  # Sortida: [1, 2, 3]
   

5. union(rdd):

   • Retorna un nou RDD que conté la unió dels elements de l'RDD original i un altre RDD.

   rdd1 = sc.parallelize([1, 2, 3])
   rdd2 = sc.parallelize([3, 4, 5])
   rdd3 = rdd1.union(rdd2)
   print(rdd3.collect())  # Sortida: [1, 2, 3, 3, 4, 5]
   

Les accions són operacions que triguen a executar-se i retornen un valor al driver program o escriuen dades a un sistema d'emmagatzematge extern. Les accions forcen l'execució de les transformacions "lazy".

1. collect():

   • Retorna tots els elements de l'RDD com una llista.

   rdd = sc.parallelize([1, 2, 3, 4])
   result = rdd.collect()
   print(result)  # Sortida: [1, 2, 3, 4]
   

2. count():

   • Retorna el nombre d'elements de l'RDD.

   rdd = sc.parallelize([1, 2, 3, 4])
   result = rdd.count()
   print(result)  # Sortida: 4
   

3. first():

   • Retorna el primer element de l'RDD.

   rdd = sc.parallelize([1, 2, 3, 4])
   result = rdd.first()
   print(result)  # Sortida: 1
   

4. take(n):

   • Retorna els primers 'n' elements de l'RDD.

   rdd = sc.parallelize([1, 2, 3, 4])
   result = rdd.take(2)
   print(result)  # Sortida: [1, 2]
   

5. reduce(funció):

   • Agrega els elements de l'RDD utilitzant una funció de reducció.

   rdd = sc.parallelize([1, 2, 3, 4])
   result = rdd.reduce(lambda x, y: x + y)
   print(result)  # Sortida: 10
   

A continuació, es mostra un exemple pràctic que combina transformacions i accions per processar un RDD.

1. Exercici 1:

   • Crea un RDD amb els números de l'1 al 20.
   • Filtra els números que són divisibles per 3.
   • Multiplica cada número resultant per 5.
   • Recull els resultats en una llista i imprimeix-la.

2. Exercici 2:

   • Crea un RDD amb una llista de paraules.
   • Utilitza flatMap per dividir cada paraula en caràcters.
   • Filtra els caràcters que són vocals.
   • Utilitza distinct per obtenir les vocals úniques.
   • Recull els resultats en una llista i imprimeix-la.

1. Solució Exercici 1:

   rdd = sc.parallelize(range(1, 21))
   rdd2 = rdd.filter(lambda x: x % 3 == 0).map(lambda x: x * 5)
   result = rdd2.collect()
   print(result)  # Sortida: [15, 30, 45, 60, 75, 90]
   

2. Solució Exercici 2:

   rdd = sc.parallelize(["apple", "banana", "cherry"])
   rdd2 = rdd.flatMap(lambda x: list(x)).filter(lambda x: x in 'aeiou').distinct()
   result = rdd2.collect()
   print(result)  # Sortida: ['a', 'e', 'i', 'o', 'u']
   

En aquesta secció, hem après sobre les transformacions i les accions en Apache Spark. Les transformacions són operacions "lazy" que creen nous RDDs, mentre que les accions són operacions que triguen a executar-se i retornen un valor o escriuen dades. Hem vist diversos exemples pràctics i exercicis per reforçar aquests conceptes. En el proper tema, explorarem els DataFrames de Spark.