Je travaille sur un PySpark DataFrame avec n colonnes. J'ai un ensemble de m colonnes (m <n) et ma tâche consiste à choisir la colonne contenant le maximum de valeurs.
Par exemple:
Entrée: PySpark DataFrame contenant col_1 = [1,2,3], col_2 = [2,1,4], col_3 = [3,2,5].
Ouput = col_4 = max (col1, col_2, col_3) = [3,2,5] dans cet exemple.
Il y a quelque chose de similaire dans les pandas, comme expliqué dans this question.
Existe-t-il un moyen de le faire dans PySpark ou dois-je modifier la conversion de mon PySpark df en Pandas df, puis effectuer les opérations?
Vous pouvez réduire l'utilisation d'expressions SQL sur une liste de colonnes:
from pyspark.sql.functions import max as max_, col, when
from functools import reduce
def row_max(*cols):
return reduce(
lambda x, y: when(x > y, x).otherwise(y),
[col(c) if isinstance(c, str) else c for c in cols]
)
df = (sc.parallelize([(1, 2, 3), (2, 1, 2), (3, 4, 5)])
.toDF(["a", "b", "c"]))
df.select(row_max("a", "b", "c").alias("max")))
Spark 1.5+ fournit également least
, greatest
from pyspark.sql.functions import greatest
df.select(greatest("a", "b", "c"))
Si vous voulez garder le nom du max, vous pouvez utiliser `structs:
from pyspark.sql.functions import struct, lit
def row_max_with_name(*cols):
cols_ = [struct(col(c).alias("value"), lit(c).alias("col")) for c in cols]
return greatest(*cols_).alias("greatest({0})".format(",".join(cols)))
maxs = df.select(row_max_with_name("a", "b", "c").alias("maxs"))
Et enfin, vous pouvez utiliser ci-dessus pour sélectionner la colonne "top" sélectionnée:
from pyspark.sql.functions import max
((_, c), ) = (maxs
.groupBy(col("maxs")["col"].alias("col"))
.count()
.agg(max(struct(col("count"), col("col"))))
.first())
df.select(c)
Vous pouvez également utiliser le pyspark intégré least
:
from pyspark.sql.functions import least, col
df = df.withColumn('min', least(col('c1'), col('c2'), col('c3')))
Une autre façon simple de le faire. Disons que la df
ci-dessous est votre cadre de données
df = sc.parallelize([(10, 10, 1 ), (200, 2, 20), (3, 30, 300), (400, 40, 4)]).toDF(["c1", "c2", "c3"])
df.show()
+---+---+---+
| c1| c2| c3|
+---+---+---+
| 10| 10| 1|
|200| 2| 20|
| 3| 30|300|
|400| 40| 4|
+---+---+---+
Vous pouvez traiter le df ci-dessus comme ci-dessous pour obtenir les résultats souhaités
from pyspark.sql.functions import lit, min
df.select( lit('c1').alias('cn1'), min(df.c1).alias('c1'),
lit('c2').alias('cn2'), min(df.c2).alias('c2'),
lit('c3').alias('cn3'), min(df.c3).alias('c3')
)\
.rdd.flatMap(lambda r: [ (r.cn1, r.c1), (r.cn2, r.c2), (r.cn3, r.c3)])\
.toDF(['Columnn', 'Min']).show()
+-------+---+
|Columnn|Min|
+-------+---+
| c1| 3|
| c2| 2|
| c3| 1|
+-------+---+
Solution Scala:
df = sc.parallelize(Seq((10, 10, 1 ), (200, 2, 20), (3, 30, 300), (400, 40, 4))).toDF("c1", "c2", "c3"))
df.rdd.map(row=>List[String](row(0).toString,row(1).toString,row(2).toString)).map(x=>(x(0),x(1),x(2),x.min)).toDF("c1","c2","c3","min").show
+---+---+---+---+
| c1| c2| c3|min|
+---+---+---+---+
| 10| 10| 1| 1|
|200| 2| 20| 2|
| 3| 30|300| 3|
|400| 40| 4| 4|
+---+---+---+---+