Andi's questions

我需要用零替换valuea 列中的最后两个值pl.DataFrame，从而我需要group_by该symbol列。

import polars as pl

df = pl.DataFrame(
    {"symbol": [*["A"] * 4, *["B"] * 4], "value": range(8)}
)

shape: (8, 2)
┌────────┬───────┐
│ symbol ┆ value │
│ ---    ┆ ---   │
│ str    ┆ i64   │
╞════════╪═══════╡
│ A      ┆ 0     │
│ A      ┆ 1     │
│ A      ┆ 2     │
│ A      ┆ 3     │
│ B      ┆ 4     │
│ B      ┆ 5     │
│ B      ┆ 6     │
│ B      ┆ 7     │
└────────┴───────┘

这是我的预期结果：

shape: (8, 2)
┌────────┬───────┐
│ symbol ┆ value │
│ ---    ┆ ---   │
│ str    ┆ i64   │
╞════════╪═══════╡
│ A      ┆ 0     │
│ A      ┆ 1     │
│ A      ┆ 0     │<-- replaced
│ A      ┆ 0     │<-- replaced
│ B      ┆ 4     │
│ B      ┆ 5     │
│ B      ┆ 0     │<-- replaced
│ B      ┆ 0     │<-- replaced
└────────┴───────┘

df = pl. DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})

print(df)

shape: (3, 2)
┌──────┬──────┐
│ col1 ┆ col2 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
└──────┴──────┘

我正在寻找polars相当于 的东西numpy.tile。
类似于df.tile(2)或 的东西df.select(pl.all().tile(2))。

预期结果应如下所示：

shape: (6, 2)
┌──────┬──────┐
│ col1 ┆ col2 │
│ ---  ┆ ---  │
│ i64  ┆ i64  │
╞══════╪══════╡
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
│ 1    ┆ 4    │
│ 2    ┆ 5    │
│ 3    ┆ 6    │
└──────┴──────┘

我正在使用 polars v1.12.0 从 Excel 表读取数据。

pl.read_excel(
    "test.xlsx",
    sheet_name="test",
    has_header=True,
    columns=list(range(30, 49))
)

请求的列已正确导入。但是，polars 为每个列名添加了后缀_1。有一个列标题_3添加了后缀。

在请求的列中，所有列标题都是唯一的，即没有重复。但是，此导入区域之前的列确实具有相同的值。例如，已加后缀的标题_3确实在我的导入区域之前出现了两次。

看起来极点正在从“A”列开始扫描所有列标题，无论我是否从“AE”列开始读取。

我想知道发生了什么事？这是一个错误还是我犯了一个错误？

我有可变数量的列pl.DataFrames，它们共享一些列（例如symbol和date）。每个列pl.DataFrame都有许多附加列，这些列对于实际任务并不重要。

这些symbol列确实具有完全相同的内容（str每个数据框中都存在不同的值）。这些date列略有不同，因为它们在每个数据框中都没有完全相同的日期pl.DataFrame。

实际任务是找到每个分组的共同日期（即symbol）并pl.DataFrame相应地过滤每个日期。

以下是三个示例pl.DataFrame：

import polars as pl

df1 = pl.DataFrame(
    {
        "symbol": ["AAPL"] * 4 + ["GOOGL"] * 3,
        "date": [
            "2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04",
            "2023-01-02", "2023-01-03", "2023-01-04",
        ],
        "some_other_col": range(7),
    }
)

df2 = pl.DataFrame(
    {
        "symbol": ["AAPL"] * 3 + ["GOOGL"] * 5,
        "date": [
            "2023-01-02", "2023-01-03", "2023-01-04",
            "2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04", "2023-01-05",
        ],
        "another_col": range(8),
    }
)

df3 = pl.DataFrame(
    {
        "symbol": ["AAPL"] * 4 + ["GOOGL"] * 2,
        "date": [
            "2023-01-02", "2023-01-03", "2023-01-04", "2023-01-05",
            "2023-01-03", "2023-01-04",
        ],
        "some_col": range(6),
    }
)
DataFrame 1:
shape: (7, 3)
┌────────┬────────────┬────────────────┐
│ symbol ┆ date       ┆ some_other_col │
│ ---    ┆ ---        ┆ ---            │
│ str    ┆ str        ┆ i64            │
╞════════╪════════════╪════════════════╡
│ AAPL   ┆ 2023-01-01 ┆ 0              │
│ AAPL   ┆ 2023-01-02 ┆ 1              │
│ AAPL   ┆ 2023-01-03 ┆ 2              │
│ AAPL   ┆ 2023-01-04 ┆ 3              │
│ GOOGL  ┆ 2023-01-02 ┆ 4              │
│ GOOGL  ┆ 2023-01-03 ┆ 5              │
│ GOOGL  ┆ 2023-01-04 ┆ 6              │
└────────┴────────────┴────────────────┘

DataFrame 2:
shape: (8, 3)
┌────────┬────────────┬─────────────┐
│ symbol ┆ date       ┆ another_col │
│ ---    ┆ ---        ┆ ---         │
│ str    ┆ str        ┆ i64         │
╞════════╪════════════╪═════════════╡
│ AAPL   ┆ 2023-01-02 ┆ 0           │
│ AAPL   ┆ 2023-01-03 ┆ 1           │
│ AAPL   ┆ 2023-01-04 ┆ 2           │
│ GOOGL  ┆ 2023-01-01 ┆ 3           │
│ GOOGL  ┆ 2023-01-02 ┆ 4           │
│ GOOGL  ┆ 2023-01-03 ┆ 5           │
│ GOOGL  ┆ 2023-01-04 ┆ 6           │
│ GOOGL  ┆ 2023-01-05 ┆ 7           │
└────────┴────────────┴─────────────┘

DataFrame 3:
shape: (6, 3)
┌────────┬────────────┬──────────┐
│ symbol ┆ date       ┆ some_col │
│ ---    ┆ ---        ┆ ---      │
│ str    ┆ str        ┆ i64      │
╞════════╪════════════╪══════════╡
│ AAPL   ┆ 2023-01-02 ┆ 0        │
│ AAPL   ┆ 2023-01-03 ┆ 1        │
│ AAPL   ┆ 2023-01-04 ┆ 2        │
│ AAPL   ┆ 2023-01-05 ┆ 3        │
│ GOOGL  ┆ 2023-01-03 ┆ 4        │
│ GOOGL  ┆ 2023-01-04 ┆ 5        │
└────────┴────────────┴──────────┘

现在，第一步是找出每个股票的共同日期symbol。AAPL
：["2023-01-02", "2023-01-03", "2023-01-04"]
GOOGL：["2023-01-03", "2023-01-04"]

这意味着，每个都pl.DataFrame需要进行相应的过滤。预期结果如下：

DataFrame 1 filtered:

shape: (5, 3)
┌────────┬────────────┬────────────────┐
│ symbol ┆ date       ┆ some_other_col │
│ ---    ┆ ---        ┆ ---            │
│ str    ┆ str        ┆ i64            │
╞════════╪════════════╪════════════════╡
│ AAPL   ┆ 2023-01-02 ┆ 1              │
│ AAPL   ┆ 2023-01-03 ┆ 2              │
│ AAPL   ┆ 2023-01-04 ┆ 3              │
│ GOOGL  ┆ 2023-01-03 ┆ 5              │
│ GOOGL  ┆ 2023-01-04 ┆ 6              │
└────────┴────────────┴────────────────┘

DataFrame 2 filtered:
shape: (5, 3)
┌────────┬────────────┬─────────────┐
│ symbol ┆ date       ┆ another_col │
│ ---    ┆ ---        ┆ ---         │
│ str    ┆ str        ┆ i64         │
╞════════╪════════════╪═════════════╡
│ AAPL   ┆ 2023-01-02 ┆ 0           │
│ AAPL   ┆ 2023-01-03 ┆ 1           │
│ AAPL   ┆ 2023-01-04 ┆ 2           │
│ GOOGL  ┆ 2023-01-03 ┆ 5           │
│ GOOGL  ┆ 2023-01-04 ┆ 6           │
└────────┴────────────┴─────────────┘

DataFrame 3 filtered:
shape: (5, 3)
┌────────┬────────────┬──────────┐
│ symbol ┆ date       ┆ some_col │
│ ---    ┆ ---        ┆ ---      │
│ str    ┆ str        ┆ i64      │
╞════════╪════════════╪══════════╡
│ AAPL   ┆ 2023-01-02 ┆ 0        │
│ AAPL   ┆ 2023-01-03 ┆ 1        │
│ AAPL   ┆ 2023-01-04 ┆ 2        │
│ GOOGL  ┆ 2023-01-03 ┆ 4        │
│ GOOGL  ┆ 2023-01-04 ┆ 5        │
└────────┴────────────┴──────────┘

我有一个pl.DataFrame包含如下列表的列：

import polars as pl

df = pl.DataFrame(
    {
        "symbol": ["A", "A", "B", "B"],
        "roc": [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8]],
    }
)

shape: (4, 2)
┌────────┬────────────┐
│ symbol ┆ roc        │
│ ---    ┆ ---        │
│ str    ┆ list[f64]  │
╞════════╪════════════╡
│ A      ┆ [0.1, 0.2] │
│ A      ┆ [0.3, 0.4] │
│ B      ┆ [0.5, 0.6] │
│ B      ┆ [0.7, 0.8] │
└────────┴────────────┘

此外，我有一个常规的 python 列表weights = [0.3, 0.7]

pl.col("roc")将乘以的一种有效方法是什么？weights即将 列的第一个和第二个元素分别与 的第一个和第二个元素相乘weights？

预期输出如下：

shape: (4, 3)
┌────────┬────────────┐──────────────┐
│ symbol ┆ roc        │ roc_wgt      │
│ ---    ┆ ---        │ ---          │
│ str    ┆ list[f64]  │ list[f64]    │
╞════════╪════════════╡══════════════╡
│ A      ┆ [0.1, 0.2] │ [0.03, 0.14] │ = [0.1 * 0.3, 0.2 * 0.7]
│ A      ┆ [0.3, 0.4] │ [0.09, 0.28] │ = [0.3 * 0.3, 0.4 * 0.7]
│ B      ┆ [0.5, 0.6] │ [0.15, 0.42] │ = [0.5 * 0.3, 0.6 * 0.7]
│ B      ┆ [0.7, 0.8] │ [0.21, 0.56] │ = [0.7 * 0.3, 0.8 * 0.7]
└────────┴────────────┘──────────────┘

假设有两个pl.DataFrame具有相同架构的 。其中一列具有dtype=pl.Enum。

import polars as pl

enum_col1 = pl.Enum(["type1"])
enum_col2 = pl.Enum(["type2"])
df1 = pl.DataFrame(
    {"enum_col": "type1", "value": 10},
    schema={"enum_col": enum_col1, "value": pl.Int64},
)
df2 = pl.DataFrame(
    {"enum_col": "type2", "value": 200},
    schema={"enum_col": enum_col2, "value": pl.Int64},
)

print(df1)
print(df2)

shape: (1, 2)
┌──────────┬───────┐
│ enum_col ┆ value │
│ ---      ┆ ---   │
│ enum     ┆ i64   │
╞══════════╪═══════╡
│ type1    ┆ 10    │
└──────────┴───────┘
shape: (1, 2)
┌──────────┬───────┐
│ enum_col ┆ value │
│ ---      ┆ ---   │
│ enum     ┆ i64   │
╞══════════╪═══════╡
│ type2    ┆ 200   │
└──────────┴───────┘

如果我尝试做一个简单的事情pl.concat([df1, df2])，我会收到以下错误：

polars.exceptions.SchemaError: type Enum(Some(local), Physical) is incompatible with expected type Enum(Some(local), Physical)

您可以通过“扩大”枚举来解决此问题，如下所示：

pl.concat(
    [
        df1.with_columns(pl.col("enum_col").cast(pl.Enum(["type1", "type2"]))),
        df2.with_columns(pl.col("enum_col").cast(pl.Enum(["type1", "type2"]))),
    ]
)

shape: (2, 2)
┌──────────┬───────┐
│ enum_col ┆ value │
│ ---      ┆ ---   │
│ enum     ┆ i64   │
╞══════════╪═══════╡
│ type1    ┆ 10    │
│ type2    ┆ 200   │
└──────────┴───────┘

我想，有更符合 Python 风格的方法来做到这一点？

我有一个简单的pl.DataFrame，其中有许多列仅包含布尔值。

import polars as pl

df = pl.DataFrame(
    {"s1": [True, True, False], "s2": [False, True, True], "s3": [False, False, False]}
)

shape: (3, 3)
┌───────┬───────┬───────┐
│ s1    ┆ s2    ┆ s3    │
│ ---   ┆ ---   ┆ ---   │
│ bool  ┆ bool  ┆ bool  │
╞═══════╪═══════╪═══════╡
│ true  ┆ false ┆ false │
│ true  ┆ true  ┆ false │
│ false ┆ true  ┆ false │
└───────┴───────┴───────┘

我需要添加另一个包含不同长度列表的列。任何单个行中的列表都应包含列名，其中 、 和 列的S1值s2都有s3值True。

这是我真正在寻找的：

shape: (3, 4)
┌───────┬───────┬───────┬──────────────┐
│ s1    ┆ s2    ┆ s3    │ list         │
│ ---   ┆ ---   ┆ ---   │ ---          │
│ bool  ┆ bool  ┆ bool  │ list[str]    │
╞═══════╪═══════╪═══════╡══════════════╡
│ true  ┆ false ┆ false │ ["s1"]       │
│ true  ┆ true  ┆ false │ ["s1", "s2"] │
│ false ┆ true  ┆ false │ ["s2"]       │
└───────┴───────┴───────┴──────────────┘

我需要计算多个交易证券的横截面排名。请考虑以下pl.DataFrame长（整齐）格式。它包含三个不同的符号，每个符号都有各自的价格，每个符号还有一个专用的（即本地）交易日历。

df = pl.DataFrame(
    {
        "symbol": [*["symbol1"] * 6, *["symbol2"] * 5, *["symbol3"] * 5],
        "date": [
            "2023-12-30", "2023-12-31", "2024-01-03", "2024-01-04", "2024-01-05", "2024-01-06",
            "2023-12-30", "2024-01-03", "2024-01-04", "2024-01-05", "2024-01-06",
            "2023-12-30", "2023-12-31", "2024-01-03", "2024-01-04", "2024-01-05",
        ],
        "price": [
            100, 105, 110, 115, 120, 125,
            200, 210, 220, 230, 240,
            3000, 3100, 3200, 3300, 3400,
        ],
    }
)

print(df)
shape: (16, 3)
┌─────────┬────────────┬───────┐
│ symbol  ┆ date       ┆ price │
│ ---     ┆ ---        ┆ ---   │
│ str     ┆ str        ┆ i64   │
╞═════════╪════════════╪═══════╡
│ symbol1 ┆ 2023-12-30 ┆ 100   │
│ symbol1 ┆ 2023-12-31 ┆ 105   │
│ symbol1 ┆ 2024-01-03 ┆ 110   │
│ symbol1 ┆ 2024-01-04 ┆ 115   │
│ symbol1 ┆ 2024-01-05 ┆ 120   │
│ …       ┆ …          ┆ …     │
│ symbol3 ┆ 2023-12-30 ┆ 3000  │
│ symbol3 ┆ 2023-12-31 ┆ 3100  │
│ symbol3 ┆ 2024-01-03 ┆ 3200  │
│ symbol3 ┆ 2024-01-04 ┆ 3300  │
│ symbol3 ┆ 2024-01-05 ┆ 3400  │
└─────────┴────────────┴───────┘

第一步是使用计算周期收益pct_change，然后使用pivot来对齐每个日期的符号。

returns = df.drop_nulls().with_columns(
    pl.col("price").pct_change(n=2).over("symbol").alias("return")
).pivot(on="symbol", index="date", values="return")

print(returns)
shape: (6, 4)
┌────────────┬──────────┬──────────┬──────────┐
│ date       ┆ symbol1  ┆ symbol2  ┆ symbol3  │
│ ---        ┆ ---      ┆ ---      ┆ ---      │
│ str        ┆ f64      ┆ f64      ┆ f64      │
╞════════════╪══════════╪══════════╪══════════╡
│ 2023-12-30 ┆ null     ┆ null     ┆ null     │
│ 2023-12-31 ┆ null     ┆ null     ┆ null     │
│ 2024-01-03 ┆ 0.1      ┆ null     ┆ 0.066667 │
│ 2024-01-04 ┆ 0.095238 ┆ 0.1      ┆ 0.064516 │
│ 2024-01-05 ┆ 0.090909 ┆ 0.095238 ┆ 0.0625   │
│ 2024-01-06 ┆ 0.086957 ┆ 0.090909 ┆ null     │
└────────────┴──────────┴──────────┴──────────┘

下一步是用来concat_list创建一个list来计算每行的排名（降序，即最高回报获得排名 1）。

ranks = (
    returns.with_columns(all_symbols=pl.concat_list(pl.all().exclude("date")))
    .select(
        pl.all().exclude("all_symbols"),
        pl.col("all_symbols")
        .list.eval(
            pl.element().rank(descending=True, method="ordinal").cast(pl.UInt8)
        )
        .alias("rank"),
    )
)

print(ranks)
shape: (6, 5)
┌────────────┬──────────┬──────────┬──────────┬────────────────────┐
│ date       ┆ symbol1  ┆ symbol2  ┆ symbol3  ┆ rank               │
│ ---        ┆ ---      ┆ ---      ┆ ---      ┆ ---                │
│ str        ┆ f64      ┆ f64      ┆ f64      ┆ list[u8]           │
╞════════════╪══════════╪══════════╪══════════╪════════════════════╡
│ 2023-12-30 ┆ null     ┆ null     ┆ null     ┆ [null, null, null] │
│ 2023-12-31 ┆ null     ┆ null     ┆ null     ┆ [null, null, null] │
│ 2024-01-03 ┆ 0.1      ┆ null     ┆ 0.066667 ┆ [1, null, 2]       │
│ 2024-01-04 ┆ 0.095238 ┆ 0.1      ┆ 0.064516 ┆ [2, 1, 3]          │
│ 2024-01-05 ┆ 0.090909 ┆ 0.095238 ┆ 0.0625   ┆ [2, 1, 3]          │
│ 2024-01-06 ┆ 0.086957 ┆ 0.090909 ┆ null     ┆ [2, 1, null]       │
└────────────┴──────────┴──────────┴──────────┴────────────────────┘

现在我们终于要开始讨论实际问题了：我
想ranks再次取消透视并生成一个整洁的数据框。我正在寻找以下列： symbol、、和。我考虑创建三个新列（基本上用来解包列表，但这只会创建新的行而不是列）。datereturnrankexplode

另外，我想知道我是否df首先需要进行旋转，或者是否有更好的方法直接df以整洁的格式对原始数据进行操作？我实际上正在寻找性能，因为df可能有数百万行。

我有两个pl.DataFrame：

from datetime import date

import polars as pl

df1 = pl.DataFrame(
    {
        "symbol": [
            "sec1", "sec1", "sec1", "sec1", "sec1", "sec1",
            "sec2", "sec2", "sec2", "sec2", "sec2",
        ],
        "date": [
            date(2021, 9, 14),
            date(2021, 9, 15),
            date(2021, 9, 16),
            date(2021, 9, 17),
            date(2021, 8, 31),
            date(2020, 12, 31),
            date(2021, 9, 14),
            date(2021, 9, 15),
            date(2021, 8, 31),
            date(2021, 12, 30),
            date(2020, 12, 31),
        ],
        "price": range(11),
    }
)

df2 = pl.DataFrame(
    {
        "symbol": ["sec1", "sec2"],
        "current_date": [date(2021, 9, 17), date(2021, 9, 15)],
        "mtd": [date(2021, 8, 31), date(2021, 8, 31)],
        "ytd": [date(2020, 12, 31), date(2020, 12, 30)],
    }
)

with pl.Config(tbl_rows=-1):
    print(df1)
    print(df2)

shape: (11, 3)
┌────────┬────────────┬───────┐
│ symbol ┆ date       ┆ price │
│ ---    ┆ ---        ┆ ---   │
│ str    ┆ date       ┆ i64   │
╞════════╪════════════╪═══════╡
│ sec1   ┆ 2021-09-14 ┆ 0     │
│ sec1   ┆ 2021-09-15 ┆ 1     │
│ sec1   ┆ 2021-09-16 ┆ 2     │
│ sec1   ┆ 2021-09-17 ┆ 3     │
│ sec1   ┆ 2021-08-31 ┆ 4     │
│ sec1   ┆ 2020-12-31 ┆ 5     │
│ sec2   ┆ 2021-09-14 ┆ 6     │
│ sec2   ┆ 2021-09-15 ┆ 7     │
│ sec2   ┆ 2021-08-31 ┆ 8     │
│ sec2   ┆ 2021-12-30 ┆ 9     │
│ sec2   ┆ 2020-12-31 ┆ 10    │
└────────┴────────────┴───────┘
shape: (2, 4)
┌────────┬──────────────┬────────────┬────────────┐
│ symbol ┆ current_date ┆ mtd        ┆ ytd        │
│ ---    ┆ ---          ┆ ---        ┆ ---        │
│ str    ┆ date         ┆ date       ┆ date       │
╞════════╪══════════════╪════════════╪════════════╡
│ sec1   ┆ 2021-09-17   ┆ 2021-08-31 ┆ 2020-12-31 │
│ sec2   ┆ 2021-09-15   ┆ 2021-08-31 ┆ 2020-12-30 │
└────────┴──────────────┴────────────┴────────────┘

我需要筛选df1每个组的价格，并根据相应的日期进行筛选df2。我需要合并所有类型的列date。这些列的数量df2可能不固定。

我正在寻找以下结果：

shape: (11, 3)
┌────────┬────────────┬───────┐
│ symbol ┆ date       ┆ price │
│ ---    ┆ ---        ┆ ---   │
│ str    ┆ date       ┆ i64   │
╞════════╪════════════╪═══════╡
│ sec1   ┆ 2021-09-17 ┆ 3     │
│ sec1   ┆ 2021-08-31 ┆ 4     │
│ sec1   ┆ 2020-12-31 ┆ 5     │
│ sec2   ┆ 2021-09-15 ┆ 7     │
│ sec2   ┆ 2021-08-31 ┆ 8     │
│ sec2   ┆ 2020-12-30 ┆ 9     │
└────────┴────────────┴───────┘

我原本想df1通过进行筛选，然后对 的每一列symbol执行连接操作。然后我会将结果数据框连接起来。不过，可能还有更优雅的解决方案。datedf2

我有一个pl.DataFrame包含整数列表的列。我需要断言每个连续整数最多连续出现两次。

例如，包含的列表[1,1,0,-1,1]是可以的，因为数字 1 在一行中最多出现两次（前两个元素，后跟零）。

此列表应该会导致断言失败：[1,1,1,0,-1]该数字1连续出现三次。

这是一个玩具示例，应该row2会导致断言失败。

import polars as pl

row1 = [0, 1, -1, -1, 1, 1, -1, 0]
row2 = [1, -1, -1, -1, 0, 0, 1, -1]
df = pl.DataFrame({"list": [row1, row2]})
print(f"row1: {row1}")
print(f"row2: {row2}")
print(df)


row1: [0, 1, -1, -1, 1, 1, -1, 0]
row2: [1, -1, -1, -1, 0, 0, 1, -1]
shape: (2, 1)
┌───────────────┐
│ list          │
│ ---           │
│ list[i64]     │
╞═══════════════╡
│ [0, 1, … 0]   │
│ [1, -1, … -1] │
└───────────────┘

请考虑以下情况pl.DataFrame：

import polars as pl

df = pl.DataFrame(
    {
        "symbol": ["s1", "s1", "s2", "s2"],
        "signal": [0, 1, 2, 0],
        "trade": [None, 1, None, -1],
    }
)

shape: (4, 3)
┌────────┬────────┬───────┐
│ symbol ┆ signal ┆ trade │
│ ---    ┆ ---    ┆ ---   │
│ str    ┆ i64    ┆ i64   │
╞════════╪════════╪═══════╡
│ s1     ┆ 0      ┆ null  │
│ s1     ┆ 1      ┆ 1     │
│ s2     ┆ 2      ┆ null  │
│ s2     ┆ 0      ┆ -1    │
└────────┴────────┴───────┘

现在，我需要对数据框进行分组，symbol并检查列中每个组的第一行signal是否不等于 0（零）。如果等于True，我需要用trade单元格中的值替换列中相应的单元格signal。

这是我真正在寻找的：

shape: (4, 3)
┌────────┬────────┬───────┐
│ symbol ┆ signal ┆ trade │
│ ---    ┆ ---    ┆ ---   │
│ str    ┆ i64    ┆ i64   │
╞════════╪════════╪═══════╡
│ s1     ┆ 0      ┆ null  │
│ s1     ┆ 1      ┆ 1     │
│ s2     ┆ 2      ┆ 2     │ <- copy value from the ``signal`` column
│ s2     ┆ 0      ┆ -1    │
└────────┴────────┴───────┘

考虑以下pl.DataFrame情况：

import datetime

import polars as pl

df_orig = pl.DataFrame(
    {
        "symbol": [*["A"] * 10, *["B"] * 8],
        "date": [
            *pl.datetime_range(
                start=datetime.date(2024, 1, 1),
                end=datetime.date(2024, 1, 10),
                eager=True,
            ),
            *pl.datetime_range(
                start=datetime.date(2024, 1, 1),
                end=datetime.date(2024, 1, 8),
                eager=True,
            ),
        ],
        "data": [*range(10), *range(8)],
    }
)

df_helper = pl.DataFrame({"symbol": ["A", "B"], "start_idx": [[0, 5], [0, 4]]})

chunk_size = 5

with pl.Config(tbl_rows=30):
    print(df_orig)
    print(df_helper)


shape: (18, 3)
┌────────┬─────────────────────┬──────┐
│ symbol ┆ date                ┆ data │
│ ---    ┆ ---                 ┆ ---  │
│ str    ┆ datetime[μs]        ┆ i64  │
╞════════╪═════════════════════╪══════╡
│ A      ┆ 2024-01-01 00:00:00 ┆ 0    │
│ A      ┆ 2024-01-02 00:00:00 ┆ 1    │
│ A      ┆ 2024-01-03 00:00:00 ┆ 2    │
│ A      ┆ 2024-01-04 00:00:00 ┆ 3    │
│ A      ┆ 2024-01-05 00:00:00 ┆ 4    │
│ A      ┆ 2024-01-06 00:00:00 ┆ 5    │
│ A      ┆ 2024-01-07 00:00:00 ┆ 6    │
│ A      ┆ 2024-01-08 00:00:00 ┆ 7    │
│ A      ┆ 2024-01-09 00:00:00 ┆ 8    │
│ A      ┆ 2024-01-10 00:00:00 ┆ 9    │
│ B      ┆ 2024-01-01 00:00:00 ┆ 0    │
│ B      ┆ 2024-01-02 00:00:00 ┆ 1    │
│ B      ┆ 2024-01-03 00:00:00 ┆ 2    │
│ B      ┆ 2024-01-04 00:00:00 ┆ 3    │
│ B      ┆ 2024-01-05 00:00:00 ┆ 4    │
│ B      ┆ 2024-01-06 00:00:00 ┆ 5    │
│ B      ┆ 2024-01-07 00:00:00 ┆ 6    │
│ B      ┆ 2024-01-08 00:00:00 ┆ 7    │
└────────┴─────────────────────┴──────┘

shape: (2, 2)
┌────────┬───────────┐
│ symbol ┆ start_idx │
│ ---    ┆ ---       │
│ str    ┆ list[i64] │
╞════════╪═══════════╡
│ A      ┆ [0, 5]    │
│ B      ┆ [0, 3]    │
└────────┴───────────┘

现在，我需要将数据框拆分为两个长度为 5 的块（chunk_size），并按symbol列分组。 列start_idx指示每个组中块的起始行。 也就是说，组 A 将被拆分为两个长度为 5 的块，从第 0 行和第 5 行开始，而组 B 的块从第 0 行和第 3 行开始。 最后，所有块都需要连接起来axis=0，从而新列split_idx指示拆分来自何处。

以下是我所寻找的内容：

shape: (20, 4)
┌────────────────────┬─────────────────────┬──────┐
│ split_idx ┆ symbol ┆ date                ┆ data │
│           ┆ ---    ┆ ---                 ┆ ---  │
│ i64       ┆ str    ┆ datetime[μs]        ┆ i64  │
╞═══════════╪════════╪═════════════════════╪══════╡
│ 0         ┆ A      ┆ 2024-01-01 00:00:00 ┆ 0    │
│ 0         ┆ A      ┆ 2024-01-02 00:00:00 ┆ 1    │
│ 0         ┆ A      ┆ 2024-01-03 00:00:00 ┆ 2    │
│ 0         ┆ A      ┆ 2024-01-04 00:00:00 ┆ 3    │
│ 0         ┆ A      ┆ 2024-01-05 00:00:00 ┆ 4    │
│ 0         ┆ B      ┆ 2024-01-01 00:00:00 ┆ 0    │
│ 0         ┆ B      ┆ 2024-01-02 00:00:00 ┆ 1    │
│ 0         ┆ B      ┆ 2024-01-03 00:00:00 ┆ 2    │
│ 0         ┆ B      ┆ 2024-01-04 00:00:00 ┆ 3    │
│ 0         ┆ B      ┆ 2024-01-05 00:00:00 ┆ 4    │
│ 1         ┆ A      ┆ 2024-01-06 00:00:00 ┆ 5    │
│ 1         ┆ A      ┆ 2024-01-07 00:00:00 ┆ 6    │
│ 1         ┆ A      ┆ 2024-01-08 00:00:00 ┆ 7    │
│ 1         ┆ A      ┆ 2024-01-09 00:00:00 ┆ 8    │
│ 1         ┆ A      ┆ 2024-01-10 00:00:00 ┆ 9    │
│ 1         ┆ B      ┆ 2024-01-04 00:00:00 ┆ 3    │
│ 1         ┆ B      ┆ 2024-01-05 00:00:00 ┆ 4    │
│ 1         ┆ B      ┆ 2024-01-06 00:00:00 ┆ 5    │
│ 1         ┆ B      ┆ 2024-01-07 00:00:00 ┆ 6    │
│ 1         ┆ B      ┆ 2024-01-08 00:00:00 ┆ 7    │
└───────────┴────────┴─────────────────────┴──────┘

请记住，列中的列表start_idx对于每一行来说长度可能都是可变的。每个列表的长度决定了每个组的块数。

考虑以下数据框。

df = pl.DataFrame(data={"col1": range(10)})

┌──────┐
│ col1 │
│ ---  │
│ i64  │
╞══════╡
│ 0    │
│ 1    │
│ 2    │
│ 3    │
│ 4    │
│ 5    │
│ 6    │
│ 7    │
│ 8    │
│ 9    │
└──────┘

假设我有一个元组列表，其中第一个值表示起始索引，第二个值表示长度值（如 中使用pl.DataFrame.slice）。这可能看起来像这样：

slices = [(1,2), (5,3)]

现在，从中切出/提取两个块的好方法是什么df，即第一个切片从第 1 行开始，长度为 2，而第二个块从第 5 行开始，长度为 3。

以下是我所寻找的内容：

┌──────┐
│ col1 │
│ ---  │
│ i64  │
╞══════╡
│ 1    │
│ 2    │
│ 5    │
│ 6    │
│ 7    │
└──────┘

考虑以下pd.DataFrame具有多个缺失值的多重索引。

import numpy as np
import pandas as pd

# Create multi-index
index = pd.MultiIndex.from_tuples(
    [
        ("A", "X", "I"),
        ("A", "X", "I"),
        ("A", "Y", "I"),
        ("A", "Y", "II"),
        ("A", "Y", "I"),
    ],
    names=["level_1", "level_2", "level_3"],
)

# Create dataframe
data = [[1, np.nan], [np.nan, 1], [np.nan, 1], [np.nan, 1], [1, np.nan]]
df = pd.DataFrame(data, index=index, columns=["column1", "column2"])

print(df)

                         column1  column2
level_1 level_2 level_3                  
A       X       I            1.0      NaN
                I            NaN      1.0
        Y       I            NaN      1.0
                II           NaN      1.0
                I            1.0      NaN

如何尽可能地挤压行？我正在寻找以下结果：

                         column1  column2
level_1 level_2 level_3                  
A       X       I            1.0      1.0
        Y       I            1.0      1.0
                II           NaN      1.0