我正在尝试使用现有列集上的groupby聚合在Pyspark中创建新列表。下面提供了一个示例输入数据框：
------------------------
id | date | value
------------------------
1 |2014-01-03 | 10
1 |2014-01-04 | 5
1 |2014-01-05 | 15
1 |2014-01-06 | 20
2 |2014-02-10 | 100
2 |2014-03-11 | 500
2 |2014-04-15 | 1500
预期输出为：
id | value_list
------------------------
1 | [10, 5, 15, 20]
2 | [100, 500, 1500]
列表中的值按日期排序。
我尝试使用collect_list，如下所示：
from pyspark.sql import functions as F
ordered_df = input_df.orderBy(['id','date'],ascending = True)
grouped_df = ordered_df.groupby("id").agg(F.collect_list("value"))
但即使我在聚合之前按日期对输入数据框进行排序，collect_list也不保证顺序。
有人可以通过保留基于第二个（日期）变量的订单来帮助如何进行聚合吗？
答案 0 :(得分：29)
from pyspark.sql import functions as F
from pyspark.sql import Window
w = Window.partitionBy('id').orderBy('date')
sorted_list_df = input_df.withColumn(
'sorted_list', F.collect_list('value').over(w)
)\
.groupBy('id')\
.agg(F.max('sorted_list').alias('sorted_list'))
Window示例通常无法解释发生了什么，所以让我为您解读。
如您所知，将collect_list与groupBy一起使用会产生无序值列表。这是因为根据数据的分区方式，一旦在组中找到一行，Spark就会将值附加到列表中。然后，订单取决于Spark如何计算您对执行程序的聚合。
Window函数允许您控制该情况，将行按特定值分组，以便您可以对每个结果组执行操作over：
w = Window.partitionBy('id').orderBy('date')
partitionBy - 您希望行的组/分区具有相同的id orderBy - 您希望组中的每一行按date 一旦定义了窗口的范围 - “具有相同id的行，按date排序” - ，您可以使用它来对其执行操作，在本例中为collect_list：
F.collect_list('value').over(w)
此时，您创建了一个新列sorted_list，其中包含按日期排序的有序值列表，但每个id仍有重复的行。要删除所需的重复行groupBy id，并为每个组保留max值：
.groupBy('id')\
.agg(F.max('sorted_list').alias('sorted_list'))
答案 1 :(得分：23)
如果您将日期和值都收集为列表，则可以使用和udf根据日期对结果列进行排序，然后仅保留结果中的值。
import operator
import pyspark.sql.functions as F
# create list column
grouped_df = input_df.groupby("id") \
.agg(F.collect_list(F.struct("date", "value")) \
.alias("list_col"))
# define udf
def sorter(l):
res = sorted(l, key=operator.itemgetter(0))
return [item[1] for item in res]
sort_udf = F.udf(sorter)
# test
grouped_df.select("id", sort_udf("list_col") \
.alias("sorted_list")) \
.show(truncate = False)
+---+----------------+
|id |sorted_list |
+---+----------------+
|1 |[10, 5, 15, 20] |
|2 |[100, 500, 1500]|
+---+----------------+
答案 2 :(得分：8)
问题出在PySpark上，但也可能对Scala Spark也有帮助。
import org.apache.spark.sql.functions._
import org.apache.spark.sql.{DataFrame, Row, SparkSession}
import org.apache.spark.sql.expressions.{ Window, UserDefinedFunction}
import java.sql.Date
import java.time.LocalDate
val spark: SparkSession = ...
// Out test data set
val data: Seq[(Int, Date, Int)] = Seq(
(1, Date.valueOf(LocalDate.parse("2014-01-03")), 10),
(1, Date.valueOf(LocalDate.parse("2014-01-04")), 5),
(1, Date.valueOf(LocalDate.parse("2014-01-05")), 15),
(1, Date.valueOf(LocalDate.parse("2014-01-06")), 20),
(2, Date.valueOf(LocalDate.parse("2014-02-10")), 100),
(2, Date.valueOf(LocalDate.parse("2014-02-11")), 500),
(2, Date.valueOf(LocalDate.parse("2014-02-15")), 1500)
)
// Create dataframe
val df: DataFrame = spark.createDataFrame(data)
.toDF("id", "date", "value")
df.show()
//+---+----------+-----+
//| id| date|value|
//+---+----------+-----+
//| 1|2014-01-03| 10|
//| 1|2014-01-04| 5|
//| 1|2014-01-05| 15|
//| 1|2014-01-06| 20|
//| 2|2014-02-10| 100|
//| 2|2014-02-11| 500|
//| 2|2014-02-15| 1500|
//+---+----------+-----+
// Group by id and aggregate date and value to new column date_value
val grouped = df.groupBy(col("id"))
.agg(collect_list(struct("date", "value")) as "date_value")
grouped.show()
grouped.printSchema()
// +---+--------------------+
// | id| date_value|
// +---+--------------------+
// | 1|[[2014-01-03,10],...|
// | 2|[[2014-02-10,100]...|
// +---+--------------------+
// udf to extract data from Row, sort by needed column (date) and return value
val sortUdf: UserDefinedFunction = udf((rows: Seq[Row]) => {
rows.map { case Row(date: Date, value: Int) => (date, value) }
.sortBy { case (date, value) => date }
.map { case (date, value) => value }
})
// Select id and value_list
val r1 = grouped.select(col("id"), sortUdf(col("date_value")).alias("value_list"))
r1.show()
// +---+----------------+
// | id| value_list|
// +---+----------------+
// | 1| [10, 5, 15, 20]|
// | 2|[100, 500, 1500]|
// +---+----------------+
val window = Window.partitionBy(col("id")).orderBy(col("date"))
val sortedDf = df.withColumn("values_sorted_by_date", collect_list("value").over(window))
sortedDf.show()
//+---+----------+-----+---------------------+
//| id| date|value|values_sorted_by_date|
//+---+----------+-----+---------------------+
//| 1|2014-01-03| 10| [10]|
//| 1|2014-01-04| 5| [10, 5]|
//| 1|2014-01-05| 15| [10, 5, 15]|
//| 1|2014-01-06| 20| [10, 5, 15, 20]|
//| 2|2014-02-10| 100| [100]|
//| 2|2014-02-11| 500| [100, 500]|
//| 2|2014-02-15| 1500| [100, 500, 1500]|
//+---+----------+-----+---------------------+
val r2 = sortedDf.groupBy(col("id"))
.agg(max("values_sorted_by_date").as("value_list"))
r2.show()
//+---+----------------+
//| id| value_list|
//+---+----------------+
//| 1| [10, 5, 15, 20]|
//| 2|[100, 500, 1500]|
//+---+----------------+
答案 3 :(得分：7)
您可以使用sort_array函数。如果您同时收集日期和值作为列表，则可以使用抱歉的数组对结果列进行排序，并仅保留所需的列。
import operator
import pyspark.sql.functions as F
grouped_df = input_df.groupby("id") \
.agg(F.sort_array(F.collect_list(F.struct("date", "value"))) \
.alias("collected_list")) \
.withColumn("sorted_list",col("collected_list.value")) \
.drop("collected_list")
.show(truncate=False)
+---+----------------+
|id |sorted_list |
+---+----------------+
|1 |[10, 5, 15, 20] |
|2 |[100, 500, 1500]|
+---+----------------+ ```````
答案 4 :(得分：4)
为了确保为每个id完成排序，我们可以使用sortWithinPartitions：
from pyspark.sql import functions as F
ordered_df = (
input_df
.repartition(input_df.id)
.sortWithinPartitions(['date'])
)
grouped_df = ordered_df.groupby("id").agg(F.collect_list("value"))
答案 5 :(得分：2)
我尝试过TMichel方法，但对我没有用。当我执行最大聚合时，我并没有获得列表的最高值。所以对我有用的是：
def max_n_values(df, key, col_name, number):
'''
Returns the max n values of a spark dataframe
partitioned by the key and ranked by the col_name
'''
w2 = Window.partitionBy(key).orderBy(f.col(col_name).desc())
output = df.select('*',
f.row_number().over(w2).alias('rank')).filter(
f.col('rank') <= number).drop('rank')
return output
def col_list(df, key, col_to_collect, name, score):
w = Window.partitionBy(key).orderBy(f.col(score).desc())
list_df = df.withColumn(name, f.collect_set(col_to_collect).over(w))
size_df = list_df.withColumn('size', f.size(name))
output = max_n_values(df=size_df,
key=key,
col_name='size',
number=1)
return output
答案 6 :(得分：1)
从Spark 2.4开始，可以使用SparkSQL的内置函数transform和array_sort（无需udf）对@mtoto的答案中创建的collect_list（ArrayType）进行后处理：
from pyspark.sql.functions import collect_list, expr, struct
df.groupby('id') \
.agg(collect_list(struct('date','value')).alias('value_list')) \
.withColumn('value_list', expr('transform(array_sort(value_list), x -> x.value)')) \
.show()
+---+----------------+
| id| value_list|
+---+----------------+
| 1| [10, 5, 15, 20]|
| 2|[100, 500, 1500]|
+---+----------------+
注意：如果需要降序，请将array_sort(value_list)更改为sort_array(value_list, False)
注意事项：如果必须将多个字段（列）按混合顺序（即orderBy('col1', desc('col2'))）排序（collect_list中的项），则array_sort（）和sort_array（）将不起作用。
答案 7 :(得分：0)
与ShadyStego的内容相辅相成，我一直在Spark上测试sortWithinPartitions和GroupBy的用法，发现它的性能比Window函数或UDF好得多。但是，使用此方法时，每个分区一次错序仍然存在问题，但是可以轻松解决。我在这里显示Spark (pySpark) groupBy misordering first element on collect_list。
此方法在大型DataFrame上特别有用，但是如果驱动程序内存不足，则可能需要大量分区。
答案 8 :(得分：0)
如果要使用spark sql，可以在这里实现。假设表名（或临时视图）为temp_table。
select
t1.id,
collect_list(value) as value_list
(Select * from temp_table order by id,date) t1
group by 1
答案 9 :(得分：0)
在 Spark SQL 世界中，答案是：
SELECT
browser, max(list)
from (
SELECT
id,
COLLECT_LIST(value) OVER (PARTITION BY id ORDER BY date DESC) as list
FROM browser_count
GROUP BYid, value, date)
Group by browser;