Comment ajouter une colonne constante dans une Étincelle DataFrame?

Je veux ajouter une colonne dans une DataFrame avec une certaine valeur arbitraire (qui est la même pour chaque ligne). J'obtiens une erreur lorsque j'utilise withColumn comme suit:

dt.withColumn('new_column', 10).head(5)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-50-a6d0257ca2be> in <module>()
      1 dt = (messages
      2     .select(messages.fromuserid, messages.messagetype, floor(messages.datetime/(1000*60*5)).alias("dt")))
----> 3 dt.withColumn('new_column', 10).head(5)

/Users/evanzamir/spark-1.4.1/python/pyspark/sql/dataframe.pyc in withColumn(self, colName, col)
   1166         [Row(age=2, name=u'Alice', age2=4), Row(age=5, name=u'Bob', age2=7)]
   1167         """
-> 1168         return self.select('*', col.alias(colName))
   1169 
   1170     @ignore_unicode_prefix

AttributeError: 'int' object has no attribute 'alias'

Il semble que j'ai peut tromper la fonction dans le travail que je veux en ajoutant et en soustrayant l'un des autres colonnes (de sorte qu'ils ajoutent à zéro), puis en ajoutant le nombre je veux (10 dans ce cas):

dt.withColumn('new_column', dt.messagetype - dt.messagetype + 10).head(5)

[Row(fromuserid=425, messagetype=1, dt=4809600.0, new_column=10),
 Row(fromuserid=47019141, messagetype=1, dt=4809600.0, new_column=10),
 Row(fromuserid=49746356, messagetype=1, dt=4809600.0, new_column=10),
 Row(fromuserid=93506471, messagetype=1, dt=4809600.0, new_column=10),
 Row(fromuserid=80488242, messagetype=1, dt=4809600.0, new_column=10)]

Cela est particulièrement hacky, droit? Je suppose que il est plus légitime façon de le faire?

InformationsquelleAutor Evan Zamir | 2015-09-25

179

Étincelle 2.2+

Étincelle 2.2 introduit typedLit à l'appui de Seq, Map, et Tuples (SPARK-19254) et les appels suivants doivent être pris en charge (la Scala):
```
import org.apache.spark.sql.functions.typedLit

df.withColumn("some_array", typedLit(Seq(1, 2, 3)))
df.withColumn("some_struct", typedLit(("foo", 1, .0.3)))
df.withColumn("some_map", typedLit(Map("key1" -> 1, "key2" -> 2)))
```
Étincelle 1.3+ (lit), 1.4+ (array, struct), 2.0+ (map):

Le deuxième argument pour DataFrame.withColumn devrait être un Column, donc vous devez utiliser un littéral:
```
from pyspark.sql.functions import lit

df.withColumn('new_column', lit(10))
```
Si vous avez besoin de complexe de colonnes que vous pouvez construire à l'aide de blocs comme array:
```
from pyspark.sql.functions import array, create_map, struct

df.withColumn("some_array", array(lit(1), lit(2), lit(3)))
df.withColumn("some_struct", struct(lit("foo"), lit(1), lit(.3)))
df.withColumn("some_map", create_map(lit("key1"), lit(1), lit("key2"), lit(2)))
```
Exactement les mêmes méthodes peuvent être utilisées en Scala.
```
import org.apache.spark.sql.functions.{array, lit, map, struct}

df.withColumn("new_column", lit(10))
df.withColumn("map", map(lit("key1"), lit(1), lit("key2"), lit(2)))
```
De fournir des noms pour structs utiliser alias sur chaque champ:
```
df.withColumn(
    "some_struct",
    struct(lit("foo").alias("x"), lit(1).alias("y"), lit(0.3).alias("z"))
 )
```
ou cast sur l'ensemble de l'objet
```
df.withColumn(
    "some_struct", 
    struct(lit("foo"), lit(1), lit(0.3)).cast("struct<x: string, y: integer, z: double>")
 )
```
Il est également possible, bien que plus lente, pour utiliser un UDF.

Note:

Les mêmes constructions peuvent être utilisés pour transmettre constante des arguments de fonctions définies par l'utilisateur ou des fonctions SQL.
- Pour d'autres, à l'aide de ce de mettre en œuvre... la withColumn méthode retourne une nouvelle DataFrame par l'ajout d'une colonne ou le remplacement de la colonne existante qui a le même nom, de sorte que vous aurez besoin de réaffecter les résultats de df ou l'affecter à une variable. Par exemple, `df = df.withColumn('new_column', éclairé(10))'
InformationsquelleAutor zero323
19

Spark 2.2 il y a deux façons d'ajouter de la valeur de la constante dans une colonne de DataFrame:

1) à l'Aide de lit

2) à l'Aide de typedLit.

La différence entre les deux est que typedLit pouvez également gérer paramétrée scala par exemple, les types de Liste, Seq, et la Carte

Exemple de DataFrame:
```
val df = spark.createDataFrame(Seq((0,"a"),(1,"b"),(2,"c"))).toDF("id", "col1")

+---+----+
| id|col1|
+---+----+
|  0|   a|
|  1|   b|
+---+----+
```
1) à l'Aide de lit: l'Ajout constant de la chaîne de valeur dans la nouvelle colonne nommée newcol:
```
import org.apache.spark.sql.functions.lit
val newdf = df.withColumn("newcol",lit("myval"))
```
Résultat:
```
+---+----+------+
| id|col1|newcol|
+---+----+------+
|  0|   a| myval|
|  1|   b| myval|
+---+----+------+
```
2) à l'Aide de typedLit:
```
import org.apache.spark.sql.functions.typedLit
df.withColumn("newcol", typedLit(("sample", 10, .044)))
```
Résultat:
```
+---+----+-----------------+
| id|col1|           newcol|
+---+----+-----------------+
|  0|   a|[sample,10,0.044]|
|  1|   b|[sample,10,0.044]|
|  2|   c|[sample,10,0.044]|
+---+----+-----------------+
```
- J'obtiens une erreur lors de l'importation typedLit
- Pourriez-vous partager la version complète avec instruction d'importation
- spark version 2.2.1. instruction d'importation est de pyspark.sql.les fonctions d'importation typedLit. Aussi essayé celui partagé par vous-même ci-dessus.
- Cela ne fonctionne pas non plus.
InformationsquelleAutor Ayush Vatsyayan

Vous devez vous connecter pour publier un commentaire.