Como alterar os nomes das colunas do quadro de dados no pyspark?

Eu venho do fundo do pandas e estou acostumado a ler dados de arquivos CSV em um dataframe e depois simplesmente alterar os nomes das colunas para algo útil usando o comando simples:

df.columns = new_column_name_list

No entanto, o mesmo não funciona em quadros de dados pyspark criados usando o sqlContext. A única solução que eu poderia descobrir para fazer isso facilmente é a seguinte:

df = sqlContext.read.format("com.databricks.spark.csv").options(header='false', inferschema='true', delimiter='\t').load("data.txt")
oldSchema = df.schema
for i,k in enumerate(oldSchema.fields):
  k.name = new_column_name_list[i]
df = sqlContext.read.format("com.databricks.spark.csv").options(header='false', delimiter='\t').load("data.txt", schema=oldSchema)

Isso basicamente define a variável duas vezes e infere o esquema primeiro, depois renomeia os nomes das colunas e carrega o quadro de dados novamente com o esquema atualizado.

Existe uma maneira melhor e mais eficiente de fazer isso, como fazemos nos pandas?

Minha versão do Spark é 1.5.0

Há muitas maneiras de fazer isso:

• Opção 1. Usando selectExpr .

  data = sqlContext.createDataFrame([("Alberto", 2), ("Dakota", 2)], 
                                    ["Name", "askdaosdka"])
  data.show()
  data.printSchema()
  
  # Output
  #+-------+----------+
  #|   Name|askdaosdka|
  #+-------+----------+
  #|Alberto|         2|
  #| Dakota|         2|
  #+-------+----------+
  
  #root
  # |-- Name: string (nullable = true)
  # |-- askdaosdka: long (nullable = true)
  
  df = data.selectExpr("Name as name", "askdaosdka as age")
  df.show()
  df.printSchema()
  
  # Output
  #+-------+---+
  #|   name|age|
  #+-------+---+
  #|Alberto|  2|
  #| Dakota|  2|
  #+-------+---+
  
  #root
  # |-- name: string (nullable = true)
  # |-- age: long (nullable = true)

• Opção 2. Usando withColumnRenamed , observe que esse método permite "substituir" a mesma coluna. Para Python3, substitua xrangepor range.

  from functools import reduce
  
  oldColumns = data.schema.names
  newColumns = ["name", "age"]
  
  df = reduce(lambda data, idx: data.withColumnRenamed(oldColumns[idx], newColumns[idx]), xrange(len(oldColumns)), data)
  df.printSchema()
  df.show()

• Opção 3. Usando o alias , no Scala você também pode usar como .

  from pyspark.sql.functions import col
  
  data = data.select(col("Name").alias("name"), col("askdaosdka").alias("age"))
  data.show()
  
  # Output
  #+-------+---+
  #|   name|age|
  #+-------+---+
  #|Alberto|  2|
  #| Dakota|  2|
  #+-------+---+

• Opção 4. Usando sqlContext.sql , que permite usar consultas SQL em DataFramesregistradas como tabelas.

  sqlContext.registerDataFrameAsTable(data, "myTable")
  df2 = sqlContext.sql("SELECT Name AS name, askdaosdka as age from myTable")
  
  df2.show()
  
  # Output
  #+-------+---+
  #|   name|age|
  #+-------+---+
  #|Alberto|  2|
  #| Dakota|  2|
  #+-------+---+

df = df.withColumnRenamed("colName", "newColName")
       .withColumnRenamed("colName2", "newColName2")

Vantagem de usar desta maneira: Com uma lista longa de colunas, você gostaria de alterar apenas alguns nomes de colunas. Isso pode ser muito conveniente nesses cenários. Muito útil ao unir tabelas com nomes de colunas duplicados.

Se você deseja alterar todos os nomes de colunas, tente df.toDF(*cols)

Caso você queira aplicar uma transformação simples em todos os nomes de colunas, este código faz o truque: (Estou substituindo todos os espaços por sublinhado)

new_column_name_list= list(map(lambda x: x.replace(" ", "_"), df.columns))

df = df.toDF(*new_column_name_list)

Obrigado a @ user8117731 pelo toDftruque.

Se você deseja renomear uma única coluna e manter o restante como está:

from pyspark.sql.functions import col
new_df = old_df.select(*[col(s).alias(new_name) if s == column_to_change else s for s in old_df.columns])

df.withColumnRenamed('age', 'age2')

esta é a abordagem que eu usei:

criar sessão pyspark:

import pyspark
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('changeColNames').getOrCreate()

criar quadro de dados:

df = spark.createDataFrame(data = [('Bob', 5.62,'juice'),  ('Sue',0.85,'milk')], schema = ["Name", "Amount","Item"])

veja df com nomes de colunas:

df.show()
+----+------+-----+
|Name|Amount| Item|
+----+------+-----+
| Bob|  5.62|juice|
| Sue|  0.85| milk|
+----+------+-----+

crie uma lista com novos nomes de coluna:

newcolnames = ['NameNew','AmountNew','ItemNew']

altere os nomes das colunas do df:

for c,n in zip(df.columns,newcolnames):
    df=df.withColumnRenamed(c,n)

visualize o df com novos nomes de coluna:

df.show()
+-------+---------+-------+
|NameNew|AmountNew|ItemNew|
+-------+---------+-------+
|    Bob|     5.62|  juice|
|    Sue|     0.85|   milk|
+-------+---------+-------+

Fiz uma função fácil de usar para renomear várias colunas para um dataframe pyspark, caso alguém queira usá-lo:

def renameCols(df, old_columns, new_columns):
    for old_col,new_col in zip(old_columns,new_columns):
        df = df.withColumnRenamed(old_col,new_col)
    return df

old_columns = ['old_name1','old_name2']
new_columns = ['new_name1', 'new_name2']
df_renamed = renameCols(df, old_columns, new_columns)

Cuidado, as duas listas devem ter o mesmo comprimento.

Outra maneira de renomear apenas uma coluna (usando import pyspark.sql.functions as F):

df = df.select( '*', F.col('count').alias('new_count') ).drop('count')

Eu uso este:

from pyspark.sql.functions import col
df.select(['vin',col('timeStamp').alias('Date')]).show()

Você pode usar a seguinte função para renomear todas as colunas do seu quadro de dados.

def df_col_rename(X, to_rename, replace_with):
    """
    :param X: spark dataframe
    :param to_rename: list of original names
    :param replace_with: list of new names
    :return: dataframe with updated names
    """
    import pyspark.sql.functions as F
    mapping = dict(zip(to_rename, replace_with))
    X = X.select([F.col(c).alias(mapping.get(c, c)) for c in to_rename])
    return X

Caso você precise atualizar apenas os nomes de algumas colunas, você pode usar o mesmo nome na lista replace_with

Para renomear todas as colunas

df_col_rename(X,['a', 'b', 'c'], ['x', 'y', 'z'])

Para renomear algumas colunas

df_col_rename(X,['a', 'b', 'c'], ['a', 'y', 'z'])

Para uma única renomeação de coluna, você ainda pode usar toDF (). Por exemplo,

df1.selectExpr("SALARY*2").toDF("REVISED_SALARY").show()

Podemos usar várias abordagens para renomear o nome da coluna.

Primeiro, vamos criar um DataFrame simples.

df = spark.createDataFrame([("x", 1), ("y", 2)], 
                                  ["col_1", "col_2"])

Agora vamos tentar renomear col_1 para col_3. PFB algumas abordagens para fazer o mesmo.

# Approach - 1 : using withColumnRenamed function.
df.withColumnRenamed("col_1", "col_3").show()

# Approach - 2 : using alias function.
df.select(df["col_1"].alias("col3"), "col_2").show()

# Approach - 3 : using selectExpr function.
df.selectExpr("col_1 as col_3", "col_2").show()

# Rename all columns
# Approach - 4 : using toDF function. Here you need to pass the list of all columns present in DataFrame.
df.toDF("col_3", "col_2").show()

Aqui está a saída.

+-----+-----+
|col_3|col_2|
+-----+-----+
|    x|    1|
|    y|    2|
+-----+-----+

Eu espero que isso ajude.