apache-spark - read - sqlcontext




Como excluir colunas no pyspark dataframe (6)

>>> a
DataFrame[id: bigint, julian_date: string, user_id: bigint]
>>> b
DataFrame[id: bigint, quan_created_money: decimal(10,0), quan_created_cnt: bigint]
>>> a.join(b, a.id==b.id, 'outer')
DataFrame[id: bigint, julian_date: string, user_id: bigint, id: bigint, quan_created_money: decimal(10,0), quan_created_cnt: bigint]

Existem dois id: bigint e eu quero excluir um. Como eu posso fazer?


Adicionando à resposta de @ Patrick, você pode usar o seguinte para soltar várias colunas

columns_to_drop = ['id', 'id_copy']
df = df.drop(*columns_to_drop)

Considere 2 dataFrames:

>>> aDF.show()
+---+----+
| id|datA|
+---+----+
|  1|  a1|
|  2|  a2|
|  3|  a3|
+---+----+

e

>>> bDF.show()
+---+----+
| id|datB|
+---+----+
|  2|  b2|
|  3|  b3|
|  4|  b4|
+---+----+

Para realizar o que você está procurando, existem 2 maneiras:

1. Condição de união diferente. Em vez de dizer aDF.id == bDF.id

aDF.join(bDF, aDF.id == bDF.id, "outer")

Escreva isso:

aDF.join(bDF, "id", "outer").show()
+---+----+----+
| id|datA|datB|
+---+----+----+
|  1|  a1|null|
|  3|  a3|  b3|
|  2|  a2|  b2|
|  4|null|  b4|
+---+----+----+

Isso eliminará automaticamente o processo extra de extração.

2. Use Aliasing: você perderá dados relacionados aos IDs específicos de B nisso.

>>> from pyspark.sql.functions import col
>>> aDF.alias("a").join(bDF.alias("b"), aDF.id == bDF.id, "outer").drop(col("b.id")).show()

+----+----+----+
|  id|datA|datB|
+----+----+----+
|   1|  a1|null|
|   3|  a3|  b3|
|   2|  a2|  b2|
|null|null|  b4|
+----+----+----+

Talvez um pouco fora de tópico, mas aqui está a solução usando o Scala. Crie uma Array de nomes de colunas do seu oldDataFrame e exclua as colunas que deseja soltar ("colExclude") . Depois passe a Array[Column] para select e descompactá-la.

val columnsToKeep: Array[Column] = oldDataFrame.columns.diff(Array("colExclude"))
                                               .map(x => oldDataFrame.col(x))
val newDataFrame: DataFrame = oldDataFrame.select(columnsToKeep: _*)

Uma maneira fácil de fazer isso é o usuário " select " e perceber que você pode obter uma lista de todas as columns para o dataframe , df , com df.columns

drop_list = ['a column', 'another column', ...]

df.select([column for column in df.columns if column not in drop_list])

Você pode nomear explicitamente as colunas que deseja manter, assim:

keep = [a.id, a.julian_date, a.user_id, b.quan_created_money, b.quan_created_cnt]

Ou, em uma abordagem mais geral, você incluiria todas as colunas, exceto uma específica por meio da compreensão de uma lista. Por exemplo, assim (excluindo a coluna de id de b ):

keep = [a[c] for c in a.columns] + [b[c] for c in b.columns if c != 'id']

Finalmente, você faz uma seleção no resultado da sua associação:

d = a.join(b, a.id==b.id, 'outer').select(*keep)

Você pode usar de duas maneiras:

1: Você apenas mantém as colunas necessárias:

drop_column_list = ["drop_column"]
df = df.select([column for column in df.columns if column not in drop_column_list])  

2: Esta é a maneira mais elegante.

df = df.drop("col_name")

Você deve evitar a versão collect (), porque ela enviará ao mestre o conjunto de dados completo, exigindo um grande esforço de computação!







pyspark