So löschen Sie Spalten im pyspark-Datenrahmen

>>> 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]

Es gibt zwei id: bigintund ich möchte einen löschen. Wie kann ich?

Beim Lesen der Spark-Dokumentation fand ich eine einfachere Lösung.

Seit Version 1.4 von spark gibt es eine Funktion drop(col), die in pyspark auf einem Datenrahmen verwendet werden kann.

Sie können es auf zwei Arten verwenden

1. df.drop('age').collect()
2. df.drop(df.age).collect()

Pyspark-Dokumentation - Drop

Wenn Sie die Antwort von @ Patrick hinzufügen, können Sie Folgendes verwenden, um mehrere Spalten zu löschen

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

Eine einfache Möglichkeit , dies zu tun ist , um Benutzer „ select“ und erkennen Sie eine Liste aller bekommen columnsfür das dataframe, dfmitdf.columns

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

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

Sie können die Spalten, die Sie behalten möchten, entweder explizit benennen, wie folgt:

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

Oder in einem allgemeineren Ansatz würden Sie alle Spalten außer einer bestimmten über ein Listenverständnis einschließen. Zum Beispiel so (ohne die idSpalte von b):

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

Schließlich treffen Sie eine Auswahl für Ihr Join-Ergebnis:

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

Sie können zwei Möglichkeiten verwenden:

1: Sie behalten nur die erforderlichen Spalten:

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

2: Dies ist der elegantere Weg.

df = df.drop("col_name")

Sie sollten die collect () -Version vermeiden, da sie den gesamten Datensatz an den Master sendet und einen hohen Rechenaufwand erfordert!

Vielleicht ein bisschen abseits des Themas, aber hier ist die Lösung mit Scala. Erstellen Sie einen ArraySpaltennamen aus Ihrem oldDataFrameund löschen Sie die Spalten, die Sie löschen möchten ("colExclude"). Dann passieren die Array[Column]auf selectund entpacken Sie es.

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

Betrachten Sie 2 dataFrames:

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

und

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

Um das zu erreichen, wonach Sie suchen, gibt es zwei Möglichkeiten:

1. Unterschiedliche Verbindungsbedingungen. Anstatt aDF.id == bDF.id zu sagen

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

Schreib Dies:

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

Dadurch wird der zusätzliche Löschvorgang automatisch beseitigt.

2. Verwenden Sie Aliasing: Sie verlieren Daten in Bezug auf B-spezifische IDs.

>>> 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|
+----+----+----+

Sie können eine Spalte wie folgt löschen:

df.drop("column Name).columns

In deinem Fall :

df.drop("id").columns

Wenn Sie mehr als eine Spalte löschen möchten, haben Sie folgende Möglichkeiten:

dfWithLongColName.drop("ORIGIN_COUNTRY_NAME", "DEST_COUNTRY_NAME")