我如何取几个列的正中位？

Question

假设我有一个由以下四个DataFrame组成的Series

use polars::prelude::*;
use chrono::prelude::*;
use chrono::Duration;

fn main() {

    let series_one = Series::new(
        "a",
        (0..4).into_iter().map(|v| v as f64).collect::<Vec<_>>(),
    );
    let series_two = Series::new(
        "a",
        (4..8).into_iter().map(|v| v as f64).collect::<Vec<_>>(),
    );
    let series_three = Series::new(
        "a",
        (8..12).into_iter().map(|v| v as f64).collect::<Vec<_>>(),
    );

    let series_dates = Series::new(
        "date",
        (0..4)
            .into_iter()
            .map(|v| NaiveDate::default() + Duration::days(v))
            .collect::<Vec<_>>(),
    );

我也是这样加入的：

    let df_one = DataFrame::new(vec![series_one, series_dates.clone()]).unwrap();
    let df_two = DataFrame::new(vec![series_two, series_dates.clone()]).unwrap();
    let df_three = DataFrame::new(vec![series_three, series_dates.clone()]).unwrap();
    let df = df_one
        .join(
            &df_two,
            ["date"],
            ["date"],
            JoinType::Outer,
            Some("1".into()),
        )
        .unwrap()
        .join(
            &df_three,
            ["date"],
            ["date"],
            JoinType::Outer,
            Some("2".into()),
        )
        .unwrap();

生成以下DataFrame

shape: (4, 4)
┌─────┬────────────┬─────┬──────┐
│ a   ┆ date       ┆ a1  ┆ a2   │
│ --- ┆ ---        ┆ --- ┆ ---  │
│ f64 ┆ date       ┆ f64 ┆ f64  │
╞═════╪════════════╪═════╪══════╡
│ 0.0 ┆ 1970-01-01 ┆ 4.0 ┆ 8.0  │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 1.0 ┆ 1970-01-02 ┆ 5.0 ┆ 9.0  │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 2.0 ┆ 1970-01-03 ┆ 6.0 ┆ 10.0 │
├╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
│ 3.0 ┆ 1970-01-04 ┆ 7.0 ┆ 11.0 │
└─────┴────────────┴─────┴──────┘

如何创建一个新的DataFrame，其中包含一个date列和一个类似的a_median列？：

┌────────────┬────────────┐
│ a_median   ┆ date       ┆
│ ---        ┆ ---        ┆
│ f64        ┆ date       ┆
╞════════════╪════════════╡
│ 4.0        ┆ 1970-01-01 ┆
├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 5.0        ┆ 1970-01-02 ┆
├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 6.0        ┆ 1970-01-03 ┆
├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌┤
│ 7.0        ┆ 1970-01-04 ┆
└────────────┴────────────┘

我认为最好通过LazyFrame来实现这一点，但我不知道如何得到准确的结果。

Answer 1

要获得所需的结果，可以使用v堆栈方法将三个DataFrames联合起来：

let mut unioned = df_one.vstack(&df_two).unwrap();
unioned = unioned.vstack(&df_three).unwrap();

一旦有了包含所有记录的单个DataFrame，就可以对它们进行分组和聚合：

let aggregated = unioned.lazy()
                        .groupby(["date"])
                        .agg([
                            col("a").median().alias("a_median")
                         ])
                         .sort(
                            "date", 
                            SortOptions {
                                descending: false, 
                                nulls_last: true
                            }
                         )
                         .collect()
                         .unwrap();

它提供了预期的结果：

    ┌────────────┬──────────┐
    │ date       ┆ a_median │
    │ ---        ┆ ---      │
    │ date       ┆ f64      │
    ╞════════════╪══════════╡
    │ 1970-01-01 ┆ 4.0      │
    ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
    │ 1970-01-02 ┆ 5.0      │
    ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
    │ 1970-01-03 ┆ 6.0      │
    ├╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌┤
    │ 1970-01-04 ┆ 7.0      │
    └────────────┴──────────┘