Come si aggiunge una nuova colonna a un Spark DataFrame (utilizzando PySpark)?

Ho uno Spark DataFrame (utilizzando PySpark 1.5.1) e vorrei aggiungere una nuova colonna.

Ho provato quanto segue senza alcun successo:

type(randomed_hours) # => list

# Create in Python and transform to RDD

new_col = pd.DataFrame(randomed_hours, columns=['new_col'])

spark_new_col = sqlContext.createDataFrame(new_col)

my_df_spark.withColumn("hours", spark_new_col["new_col"])

Ho anche ricevuto un errore usando questo:

my_df_spark.withColumn("hours",  sc.parallelize(randomed_hours))

Allora come aggiungo una nuova colonna (basata sul vettore Python) a un DataFrame esistente con PySpark?

Non è possibile aggiungere una colonna arbitraria a DataFramein Spark. Le nuove colonne possono essere create solo utilizzando i letterali (altri tipi di letterali sono descritti in Come aggiungere una colonna costante in un Spark DataFrame? )

from pyspark.sql.functions import lit

df = sqlContext.createDataFrame(
    [(1, "a", 23.0), (3, "B", -23.0)], ("x1", "x2", "x3"))

df_with_x4 = df.withColumn("x4", lit(0))
df_with_x4.show()

## +---+---+-----+---+
## | x1| x2|   x3| x4|
## +---+---+-----+---+
## |  1|  a| 23.0|  0|
## |  3|  B|-23.0|  0|
## +---+---+-----+---+

trasformare una colonna esistente:

from pyspark.sql.functions import exp

df_with_x5 = df_with_x4.withColumn("x5", exp("x3"))
df_with_x5.show()

## +---+---+-----+---+--------------------+
## | x1| x2|   x3| x4|                  x5|
## +---+---+-----+---+--------------------+
## |  1|  a| 23.0|  0| 9.744803446248903E9|
## |  3|  B|-23.0|  0|1.026187963170189...|
## +---+---+-----+---+--------------------+

incluso utilizzando join:

from pyspark.sql.functions import exp

lookup = sqlContext.createDataFrame([(1, "foo"), (2, "bar")], ("k", "v"))
df_with_x6 = (df_with_x5
    .join(lookup, col("x1") == col("k"), "leftouter")
    .drop("k")
    .withColumnRenamed("v", "x6"))

## +---+---+-----+---+--------------------+----+
## | x1| x2|   x3| x4|                  x5|  x6|
## +---+---+-----+---+--------------------+----+
## |  1|  a| 23.0|  0| 9.744803446248903E9| foo|
## |  3|  B|-23.0|  0|1.026187963170189...|null|
## +---+---+-----+---+--------------------+----+

o generato con function / udf:

from pyspark.sql.functions import rand

df_with_x7 = df_with_x6.withColumn("x7", rand())
df_with_x7.show()

## +---+---+-----+---+--------------------+----+-------------------+
## | x1| x2|   x3| x4|                  x5|  x6|                 x7|
## +---+---+-----+---+--------------------+----+-------------------+
## |  1|  a| 23.0|  0| 9.744803446248903E9| foo|0.41930610446846617|
## |  3|  B|-23.0|  0|1.026187963170189...|null|0.37801881545497873|
## +---+---+-----+---+--------------------+----+-------------------+

Dal punto di vista delle prestazioni, le funzioni integrate ( pyspark.sql.functions), che mappano all'espressione Catalyst, sono generalmente preferite rispetto alle funzioni Python definite dall'utente.

Se vuoi aggiungere il contenuto di un RDD arbitrario come colonna puoi farlo

• aggiungere i numeri di riga al data frame esistente
• chiama zipWithIndexRDD e convertilo in data frame
• unisci entrambi usando index come chiave di join

Per aggiungere una colonna utilizzando una UDF:

df = sqlContext.createDataFrame(
    [(1, "a", 23.0), (3, "B", -23.0)], ("x1", "x2", "x3"))

from pyspark.sql.functions import udf
from pyspark.sql.types import *

def valueToCategory(value):
   if   value == 1: return 'cat1'
   elif value == 2: return 'cat2'
   ...
   else: return 'n/a'

# NOTE: it seems that calls to udf() must be after SparkContext() is called
udfValueToCategory = udf(valueToCategory, StringType())
df_with_cat = df.withColumn("category", udfValueToCategory("x1"))
df_with_cat.show()

## +---+---+-----+---------+
## | x1| x2|   x3| category|
## +---+---+-----+---------+
## |  1|  a| 23.0|     cat1|
## |  3|  B|-23.0|      n/a|
## +---+---+-----+---------+

Per Spark 2.0

# assumes schema has 'age' column 
df.select('*', (df.age + 10).alias('agePlusTen'))

Esistono diversi modi per aggiungere una nuova colonna in pySpark.

Creiamo prima un semplice DataFrame.

date = [27, 28, 29, None, 30, 31]
df = spark.createDataFrame(date, IntegerType())

Ora proviamo a raddoppiare il valore della colonna e memorizzarlo in una nuova colonna. PFB pochi approcci diversi per ottenere lo stesso.

# Approach - 1 : using withColumn function
df.withColumn("double", df.value * 2).show()

# Approach - 2 : using select with alias function.
df.select("*", (df.value * 2).alias("double")).show()

# Approach - 3 : using selectExpr function with as clause.
df.selectExpr("*", "value * 2 as double").show()

# Approach - 4 : Using as clause in SQL statement.
df.createTempView("temp")
spark.sql("select *, value * 2 as double from temp").show()

Per ulteriori esempi e spiegazioni sulle funzioni di Spark DataFrame, puoi visitare il mio blog .

Spero che aiuti.

Puoi definirne uno nuovo udfquando aggiungi un column_name:

u_f = F.udf(lambda :yourstring,StringType())
a.select(u_f().alias('column_name')

from pyspark.sql.functions import udf
from pyspark.sql.types import *
func_name = udf(
    lambda val: val, # do sth to val
    StringType()
)
df.withColumn('new_col', func_name(df.old_col))

Vorrei offrire un esempio generalizzato per un caso d'uso molto simile:

Caso d'uso: ho un CSV composto da:

First|Third|Fifth
data|data|data
data|data|data
...billion more lines

Devo eseguire alcune trasformazioni e il CSV finale deve assomigliare

First|Second|Third|Fourth|Fifth
data|null|data|null|data
data|null|data|null|data
...billion more lines

Devo farlo perché questo è lo schema definito da un modello e ho bisogno che i miei dati finali siano interoperabili con gli inserimenti in blocco SQL e cose del genere.

così:

1) Ho letto il csv originale usando spark.read e lo chiamo "df".

2) Faccio qualcosa ai dati.

3) Aggiungo le colonne nulle usando questo script:

outcols = []
for column in MY_COLUMN_LIST:
    if column in df.columns:
        outcols.append(column)
    else:
        outcols.append(lit(None).cast(StringType()).alias('{0}'.format(column)))

df = df.select(outcols)

In questo modo, puoi strutturare il tuo schema dopo aver caricato un csv (funzionerebbe anche per riordinare le colonne se devi farlo per molte tabelle).

Il modo più semplice per aggiungere una colonna è utilizzare "withColumn". Poiché il dataframe viene creato utilizzando sqlContext, è necessario specificare lo schema o per impostazione predefinita può essere disponibile nel set di dati. Se lo schema è specificato, il carico di lavoro diventa noioso quando cambia ogni volta.

Di seguito è riportato un esempio che puoi considerare:

from pyspark.sql import SQLContext
from pyspark.sql.types import *
sqlContext = SQLContext(sc) # SparkContext will be sc by default 

# Read the dataset of your choice (Already loaded with schema)
Data = sqlContext.read.csv("/path", header = True/False, schema = "infer", sep = "delimiter")

# For instance the data has 30 columns from col1, col2, ... col30. If you want to add a 31st column, you can do so by the following:
Data = Data.withColumn("col31", "Code goes here")

# Check the change 
Data.printSchema()

Possiamo aggiungere colonne aggiuntive a DataFrame direttamente con i passaggi seguenti:

from pyspark.sql.functions import when
df = spark.createDataFrame([["amit", 30], ["rohit", 45], ["sameer", 50]], ["name", "age"])
df = df.withColumn("profile", when(df.age >= 40, "Senior").otherwise("Executive"))
df.show()