Ajout d'une colonne de rowsums à travers une liste de colonnes dans Spark Dataframe

J'ai une Étincelle dataframe avec plusieurs colonnes. Je veux ajouter une colonne sur le dataframe qui est une somme d'un certain nombre de colonnes.

Par exemple, mes données ressemble à ceci:

ID var1 var2 var3 var4 var5
a   5     7    9    12   13
b   6     4    3    20   17
c   4     9    4    6    9
d   1     2    6    8    1

Je veux une colonne ajoutée en additionnant les lignes des colonnes spécifiques:

ID var1 var2 var3 var4 var5   sums
a   5     7    9    12   13    46
b   6     4    3    20   17    50
c   4     9    4    6    9     32
d   1     2    6    8    10    27

Je sais qu'il est possible d'ajouter des colonnes si vous connaissez les colonnes à ajouter: 

val newdf = df.withColumn("sumofcolumns", df("var1") + df("var2"))

Mais est-il possible de passer d'une liste de noms de colonnes et les additionner? En fonction de cette réponse, qui est essentiellement ce que je veux mais c'est à l'aide de l'API python à la place de la scala (Ajouter une colonne somme comme nouvelle colonne dans PySpark dataframe) je pense que quelque chose de ce genre: 

//Select columns to sum
val columnstosum = ("var1", "var2","var3","var4","var5")

//Create new column called sumofcolumns which is sum of all columns listed in columnstosum
val newdf = df.withColumn("sumofcolumns", df.select(columstosum.head, columnstosum.tail: _*).sum)

Ce lève la valeur de l'erreur de somme n'est pas membre de l'organisation.apache.spark.sql.DataFrame. Est-il un moyen de somme à travers les colonnes?

Merci d'avance pour votre aide.

InformationsquelleAutor Sarah | 2016-06-03
  1. 31

    Vous devriez essayer le suivant:

    import org.apache.spark.sql.functions._

val sc: SparkContext = ...
val sqlContext = new SQLContext(sc)

import sqlContext.implicits._

val input = sc.parallelize(Seq(
  ("a", 5, 7, 9, 12, 13),
  ("b", 6, 4, 3, 20, 17),
  ("c", 4, 9, 4, 6 , 9),
  ("d", 1, 2, 6, 8 , 1)
)).toDF("ID", "var1", "var2", "var3", "var4", "var5")

val columnsToSum = List(col("var1"), col("var2"), col("var3"), col("var4"), col("var5"))

val output = input.withColumn("sums", columnsToSum.reduce(_ + _))

output.show()

    Alors le résultat est:

    +---+----+----+----+----+----+----+
| ID|var1|var2|var3|var4|var5|sums|
+---+----+----+----+----+----+----+
|  a|   5|   7|   9|  12|  13|  46|
|  b|   6|   4|   3|  20|  17|  50|
|  c|   4|   9|   4|   6|   9|  32|
|  d|   1|   2|   6|   8|   1|  18|
+---+----+----+----+----+----+----+
    InformationsquelleAutor Paweł Jurczenko
  2. 9

    Clair et simple:

    import org.apache.spark.sql.Column
import org.apache.spark.sql.functions.{lit, col}

def sum_(cols: Column*) = cols.foldLeft(lit(0))(_ + _)

val columnstosum = Seq("var1", "var2", "var3", "var4", "var5").map(col _)
df.select(sum_(columnstosum: _*))

    avec Python équivalent:

    from functools import reduce
from operator import add
from pyspark.sql.functions import lit, col

def sum_(*cols):
    return reduce(add, cols, lit(0))

columnstosum = [col(x) for x in ["var1", "var2", "var3", "var4", "var5"]]
select("*", sum_(*columnstosum))

    À la fois par défaut NA si il manque une valeur dans la ligne. Vous pouvez utiliser DataFrameNaFunctions.fill ou coalesce fonction d'éviter que.

    InformationsquelleAutor zero323
  3. 2

    Je suppose que vous avez un dataframe df. Ensuite, vous pouvez additionner tous les cols, à l'exception de votre ID col. Cette fonction est utile lorsque vous avez beaucoup de cols et vous ne voulez pas manuellement mentionner les noms de toutes les colonnes, comme tout le monde mentionnés ci-dessus. Ce post a la même réponse. 

    val sumAll = df.columns.collect{ case x if x != "ID" => col(x) }.reduce(_ + _)
df.withColumn("sum", sumAll)
    InformationsquelleAutor Abu Shoeb
  4. 0

    Voici une solution élégante à l'aide de python:

    NewDF = OldDF.withColumn('sums', sum(OldDF[col] for col in OldDF.columns[1:]))

    J'espère que cela va influencer quelque chose de semblable dans l'Étincelle ... quelqu'un?.

    InformationsquelleAutor Aerianis