Tengo el siguiente DataFrame:

January | February | March
-----------------------------
  10    |    10    |  10
  20    |    20    |  20
  50    |    50    |  50

Estoy tratando de agregar una columna a esta que es la suma de los valores de cada fila.

January | February | March  | TOTAL
----------------------------------
  10    |    10    |   10   |  30
  20    |    20    |   20   |  60
  50    |    50    |   50   |  150

Tan lejos como puedo ver, todo el construido en funciones de agregado parecen ser para el cálculo de los valores en columnas individuales. ¿Cómo ir sobre el uso de los valores a través de columnas en cada fila (usando Scala)?

He llegado tan lejos como

val newDf: DataFrame = df.select(colsToSum.map(col):_*).foreach ...
¿Qué es colsToSum? Tal Vez Lista[Columna] ?

OriginalEl autor karoma | 2016-04-01

5 Comentarios

  1. 13

    Que estaban muy cerca con este:

    val newDf: DataFrame = df.select(colsToSum.map(col):_*).foreach ...

    Lugar, intente esto:

    val newDf = df.select(colsToSum.map(col).reduce((c1, c2) => c1 + c2) as "sum")

    Creo que esta es la mejor de las respuestas, porque es tan rápido como la respuesta con la rígida consulta SQL, y tan conveniente como la que utiliza el UDF. Es el mejor de ambos mundos-y ni siquiera tuve que agregar una línea de código!

    Hola David, hay una manera similar a la que encontrar el mínimo en lugar de la suma?
    Esta es la parte superior de mi cabeza, y no he tocado chispa en aproximadamente 6 meses, pero intenta algo como cambiar: (c1, c2) => c1 + c2 a (c1, c2) => if (c1 < c2) c1; else c2
    Gracias Daivd, he probado esta solución y no funcionó
    Tengo escenario similar, pero tengo más de 300 columnas de la suma, he probado la solución, pero falló debido a max iteración exceder, alguna sugerencia ?

    OriginalEl autor David Griffin

  2. 7

    Este código en Python, pero puede ser fácilmente traducida:

    # First we create a RDD in order to create a dataFrame:
    rdd = sc.parallelize([(10, 10,10), (20, 20,20)])
    df = rdd.toDF(['January', 'February', 'March'])
    df.show()
    
    # Here, we create a new column called 'TOTAL' which has results
    # from add operation of columns df.January, df.February and df.March
    
    df.withColumn('TOTAL', df.January + df.February + df.March).show()

    De salida:

    +-------+--------+-----+
    |January|February|March|
    +-------+--------+-----+
    |     10|      10|   10|
    |     20|      20|   20|
    +-------+--------+-----+
    
    +-------+--------+-----+-----+
    |January|February|March|TOTAL|
    +-------+--------+-----+-----+
    |     10|      10|   10|   30|
    |     20|      20|   20|   60|
    +-------+--------+-----+-----+

    También se puede crear una Función Definida por el Usuario que desea, aquí un enlace de la Chispa de la documentación:
    UserDefinedFunction (udf)

    OriginalEl autor Hugo Reyes

  3. 7

    De forma alternativa y el uso de Hugo del enfoque y el ejemplo, puede crear un UDF que recibe cualquier cantidad de columnas y sum todos ellos.

    from functools import reduce
    
    def superSum(*cols):
       return reduce(lambda a, b: a + b, cols)
    
    add = udf(superSum)
    
    df.withColumn('total', add(*[df[x] for x in df.columns])).show()
    
    
    +-------+--------+-----+-----+
    |January|February|March|total|
    +-------+--------+-----+-----+
    |     10|      10|   10|   30|
    |     20|      20|   20|   60|
    +-------+--------+-----+-----+

    OriginalEl autor Alberto Bonsanto

  4. 4

    Puede utilizar expr() para esto.En scala uso

    df.withColumn("TOTAL", expr("January+February+March"))

    OriginalEl autor Himaprasoon

  5. 4

    De trabajo Scala ejemplo con la dinámica de la columna de selección:

    import sqlContext.implicits._
    val rdd = sc.parallelize(Seq((10, 10, 10), (20, 20, 20)))
    val df = rdd.toDF("January", "February", "March")
    df.show()
    
    +-------+--------+-----+
    |January|February|March|
    +-------+--------+-----+
    |     10|      10|   10|
    |     20|      20|   20|
    +-------+--------+-----+
    
    val sumDF = df.withColumn("TOTAL", df.columns.map(c => col(c)).reduce((c1, c2) => c1 + c2))
    sumDF.show()
    
    +-------+--------+-----+-----+
    |January|February|March|TOTAL|
    +-------+--------+-----+-----+
    |     10|      10|   10|   30|
    |     20|      20|   20|   60|
    +-------+--------+-----+-----+
    Es allí una manera de hacer esto de forma dinámica no a través de las columnas, pero en las filas? Significado, sin tener que recurrir a escribir en spark.sql("select sum(col1), sum(col1) from df"), podemos sumar el otro camino (hacia abajo las columnas, no a lo largo) con una concisa declaración?
    df.select(df.columns.map(c => sum(col(c))) :_*) ?

    OriginalEl autor Paweł Kaczorowski

Dejar respuesta

Please enter your comment!
Please enter your name here