Apache Spark: acciones

Mi respuesta a la tarea: 

mi respuesta del reto1:    

Mi solucion 


Mi solución:   


Mi solución gente:   

MI tarea:  

Asi lo resolvi:  

`# ejerciciolista_nros = [1,2,3,4,5,6,7,8,9,10]rdd_homework = sc.parallelize(lista_nros)rdd_homework.collect()#print (f'el RRD esta compuesto por: {rdd_homework}')rdd_par =  rdd_homework.filter( lambda x : x % 2 == 0) #filtro para obtener los numeros pares.rdd_par.collect()# maximos y minimos rdd_max = rdd_homework.max()rdd_min = rdd_homework.min()print  (f'el maximo es {rdd_max} y el minimo es {rdd_min}')rdd_sumavg = rdd_max + rdd_minrdd_avg = rdd_sumavg / 2print(f'el promedio es: {rdd_avg}')# calculando promedio de la lista de numeros con meanrdd_avg = rdd_homework.mean()print(f'el promedio es: {rdd_avg}')# uniendo dos RDDslista_nrostwo = [1,3,5,7,9,11,13,15,17,19,21]rdd_homeworktwo = sc.parallelize(lista_nrostwo)rdd_homeworktwo.collect()` `rdd_join = rdd_homework.union(rdd_homeworktwo)rdd_join.collect()`

  Done!

Mis respuestas:     

I am a fan of these exercises

Hola! Comparto mi solución al reto: 

```python #Create a RDD list_1_10 = [1,2,3,4,5,6,7,8,9,10] list_rdd = sc.parallelize(list_1_10) list_rdd.collect() #Filter pair values pair_values = list_rdd.filter(lambda x : x % 2 == 0) pair_values.collect() #Find Max and Min in the list display("The max number of the list is:",list_rdd.max(), "The min number of the list is:",list_rdd.min()) #Find the average of the list display("The average of the list is:", list_rdd.mean()) #Join RDDs join_rdd = list_rdd.union(pair_values) join_rdd.collect() ```#Create a RDDlist\_1\_10 = \[1,2,3,4,5,6,7,8,9,10] list\_rdd = sc.parallelize(list\_1\_10)list\_rdd.collect()

comparto el código:  

Adjunto mi tarea profe:   

En Apache Spark, las **acciones** son operaciones que ejecutan el flujo de transformaciones definido sobre un RDD, DataFrame o Dataset, devolviendo un resultado al controlador (driver) o guardando los datos en almacenamiento externo. A diferencia de las transformaciones, que son **evaluadas de forma perezosa**, las acciones **desencadenan la ejecución** de todas las transformaciones previas en el pipeline. ### **Características de las Acciones** 1. **Inicia el cálculo**: Producen un resultado final o guardan datos en un sistema externo. 2. **Devuelve un valor**: El resultado puede ser un valor al controlador, un conteo, una lista de elementos o datos almacenados. 3. **Forzan la evaluación**: Ejecutan todas las transformaciones acumuladas hasta ese punto. 4. **Consume recursos del clúster**: Las acciones generan cargas en los nodos al procesar los datos. ### **Principales Acciones en Spark** A continuación, se describen las acciones más comunes, junto con ejemplos en Python y Scala. #### 1. `collect()` * Recupera todos los elementos del RDD o DataFrame y los devuelve al controlador como una lista. * **Uso**: * Ideal para conjuntos de datos pequeños, ya que todos los datos deben caber en la memoria del controlador. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 3, 4, 5]) resultado = rdd.collect() print(resultado) # Salida: \[1, 2, 3, 4, 5] #### 2. `count()` * Cuenta el número total de elementos en un RDD o DataFrame. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 3, 4, 5]) total = rdd.count() print(total) # Salida: 5 #### 3. `take(n)` * Recupera los primeros `n` elementos del RDD o DataFrame. * **Ejemplo**:rdd = sc.parallelize(\[10, 20, 30, 40, 50]) primeros = rdd.take(3) print(primeros) # Salida: \[10, 20, 30] #### 4. `reduce(función)` * Aplica una función de reducción a los elementos del RDD o DataFrame y devuelve un único valor. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 3, 4]) suma = rdd.reduce(lambda x, y: x + y) print(suma) # Salida: 10 #### 5. `first()` * Devuelve el primer elemento del RDD o DataFrame. * **Ejemplo**:rdd = sc.parallelize(\[100, 200, 300]) primero = rdd.first() print(primero) # Salida: 100 #### 6. `saveAsTextFile(path)` * Guarda el RDD como un archivo de texto en la ruta especificada. Cada partición se almacena como un archivo separado. * **Ejemplo**:rdd = sc.parallelize(\["Hola", "Mundo", "Spark"]) rdd.saveAsTextFile("ruta/salida.txt") #### 7. `saveAsSequenceFile(path)` * Guarda los datos como un archivo de secuencia (usado para claves y valores). * **Ejemplo**:rdd = sc.parallelize(\[(1, "A"), (2, "B"), (3, "C")]) rdd.saveAsSequenceFile("ruta/salida-secuencia") #### 8. `countByValue()` * Devuelve un mapa con la frecuencia de cada elemento en el RDD. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 2, 3, 3, 3]) frecuencias = rdd.countByValue() print(frecuencias) # Salida: {1: 1, 2: 2, 3: 3} #### 9. `foreach(función)` * Aplica una función a cada elemento del RDD sin devolver un resultado al controlador. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 3]) rdd.foreach(lambda x: print(x)) # Imprime cada elemento #### 10. `takeSample(withReplacement, num, seed=None)` * Devuelve una muestra de elementos del RDD. * **Parámetros**: * `withReplacement`: Indica si los elementos pueden repetirse en la muestra. * `num`: Tamaño de la muestra. * `seed`: Semilla opcional para reproducibilidad. * **Ejemplo**:rdd = sc.parallelize(\[1, 2, 3, 4, 5]) muestra = rdd.takeSample(False, 3, seed=42) print(muestra) # Salida: \[1, 4, 5] #### 11. `saveAsObjectFile(path)` * Serializa el RDD y lo guarda como un archivo binario en la ruta especificada. * **Ejemplo**:rdd = sc.parallelize(\["a", "b", "c"]) rdd.saveAsObjectFile("ruta/archivo\_objeto") ### **Consideraciones importantes** * Usar acciones como `collect()` o `take()` con datos grandes puede saturar la memoria del controlador. En esos casos, es mejor usar acciones que guarden los datos en almacenamiento externo. * Las acciones desencadenan todas las transformaciones pendientes, por lo que es esencial diseñar flujos eficientes. ### **Ejemplo de flujo completo** from pyspark import SparkContext \# Crear un contexto de Spark sc = SparkContext("local", "AccionesEjemplo") \# Crear un RDD rdd = sc.parallelize(\[1, 2, 3, 4, 5, 6]) \# Transformaciones rdd\_pares = rdd.filter(lambda x: x % 2 == 0) rdd\_cuadrados = rdd\_pares.map(lambda x: x\*\*2) \# Acción resultado = rdd\_cuadrados.collect() print(resultado) # Salida: \[4, 16, 36] \# Detener el contexto sc.stop() En este flujo: 1. Se crean transformaciones (`filter` y `map`) para filtrar números pares y elevarlos al cuadrado. 2. Se ejecuta la acción `collect()` para obtener el resultado final.

 ![]() ![]()solo me faltó el AVG ☺️

Vi en los comentarios que para unir se usa la funcion "Union" pero al intentarlo de la siguiente manera tambien funcionó. Es correcto? 

Comparto mi solución al reto de la clase:  ![]() ![]()![]()![]()