En este tema, exploraremos dos conceptos fundamentales en Apache Spark: las transformaciones y las acciones. Estos conceptos son esenciales para entender cómo manipular y procesar datos en Spark.

Las transformaciones en Spark son operaciones que se aplican a un RDD (Resilient Distributed Dataset) y producen un nuevo RDD. Las transformaciones son perezosas, lo que significa que no se ejecutan inmediatamente. En lugar de eso, se registran en un plan de ejecución que se ejecuta cuando se llama a una acción.

1. map(función): Aplica una función a cada elemento del RDD y devuelve un nuevo RDD con los resultados.

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

2. filter(función): Filtra los elementos del RDD que no cumplen con una condición.

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

3. flatMap(función): Similar a map, pero cada entrada puede ser mapeada a cero o más elementos de salida (es decir, puede devolver una lista de elementos).

   rdd = sc.parallelize(["hello world", "hi"])
   rdd2 = rdd.flatMap(lambda x: x.split(" "))
   print(rdd2.collect())  # Salida: ['hello', 'world', 'hi']
   

4. distinct(): Devuelve un nuevo RDD con elementos únicos.

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

5. union(rdd): Devuelve un nuevo RDD que contiene los elementos de ambos RDDs.

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

6. intersection(rdd): Devuelve un nuevo RDD que contiene solo los elementos comunes a ambos RDDs.

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

Las acciones en Spark son operaciones que devuelven un valor al controlador del programa o escriben datos a un sistema de almacenamiento externo. Las acciones desencadenan la ejecución de las transformaciones perezosas.

1. collect(): Devuelve todos los elementos del RDD como una lista.

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

2. count(): Devuelve el número de elementos en el RDD.

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

3. first(): Devuelve el primer elemento del RDD.

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

4. take(n): Devuelve los primeros n elementos del RDD.

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

5. reduce(función): Aplica una función de reducción a los elementos del RDD.

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

6. saveAsTextFile(path): Escribe los elementos del RDD en un archivo de texto en el sistema de archivos.

   rdd = sc.parallelize([1, 2, 3, 4])
   rdd.saveAsTextFile("/ruta/al/archivo")
   

1. Crea un RDD a partir de la lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
2. Aplica una transformación filter para obtener solo los números pares.
3. Aplica una transformación map para multiplicar cada número por 2.
4. Usa la acción collect para obtener los resultados y muéstralos.

Solución

1. Crea un RDD a partir de la lista [10, 20, 30, 40, 50].
2. Usa la acción count para contar el número de elementos en el RDD.
3. Usa la acción first para obtener el primer elemento del RDD.
4. Usa la acción reduce para sumar todos los elementos del RDD.

Solución

En esta sección, hemos aprendido sobre las transformaciones y acciones en Apache Spark. Las transformaciones son operaciones perezosas que crean nuevos RDDs, mientras que las acciones desencadenan la ejecución de estas transformaciones y devuelven resultados. Comprender estos conceptos es crucial para trabajar eficientemente con Spark y manipular grandes volúmenes de datos.

En el próximo tema, exploraremos los DataFrames de Spark, una abstracción de datos más avanzada y optimizada que facilita el trabajo con datos estructurados.