Andi's questions

Preciso calcular a porcentagem de valores positivos na valuecoluna agrupados pela groupcoluna.

import polars as pl

df = pl.DataFrame(
    {
        "group": ["A", "A", "A", "A", "A", "B", "B", "B", "B", "B"],
        "value": [2, -1, 3, 1, -2, 1, 2, -1, 3, 2],
    }
)

shape: (10, 2)
┌───────┬───────┐
│ group ┆ value │
│ ---   ┆ ---   │
│ str   ┆ i64   │
╞═══════╪═══════╡
│ A     ┆ 2     │
│ A     ┆ -1    │
│ A     ┆ 3     │
│ A     ┆ 1     │
│ A     ┆ -2    │
│ B     ┆ 1     │
│ B     ┆ 2     │
│ B     ┆ -1    │
│ B     ┆ 3     │
│ B     ┆ 2     │
└───────┴───────┘

No grupo Ahá 3 de 5 valores positivos (60%), enquanto na coluna Bhá 4 de 5 valores positivos (80%).

Aqui está o dataframe esperado.

┌────────┬──────────────────┐
│ group  ┆ positive_percent │
│ ---    ┆ ---              │
│ str    ┆ f64              │
╞════════╪══════════════════╡
│ A      ┆ 0.6              │
│ B      ┆ 0.8              │
└────────┴──────────────────┘

Preciso substituir os dois últimos valores na valuecoluna a pl.DataFramepor zeros, por isso preciso da group_bycoluna 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     │
└────────┴───────┘

Aqui está o meu resultado esperado:

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    │
└──────┴──────┘

Estou procurando o polarsequivalente a numpy.tile.
Algo parecido com df.tile(2)ou df.select(pl.all().tile(2)).

O resultado esperado deve ser semelhante a este:

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

Estou usando o polars v1.12.0 para ler dados de uma planilha do Excel.

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

As colunas solicitadas estão sendo importadas corretamente. No entanto, o polars adiciona um sufixo _1a cada nome de coluna. Há um cabeçalho de coluna onde um _3foi adicionado.

Nas colunas solicitadas, todos os cabeçalhos de coluna são únicos, ou seja, sem duplicatas. No entanto, as colunas antes desta área de importação têm os mesmos valores. Por exemplo, o cabeçalho que foi sufixado _3ocorre duas vezes antes da minha área de importação.

Parece que o Polars está escaneando todos os cabeçalhos de coluna a partir da coluna "A", não importa se eu começo a ler a partir da coluna "AE".

Estou me perguntando o que está acontecendo? Isso é um bug ou eu cometi um erro?

Tenho um número variável de pl.DataFramesque compartilham algumas colunas (por exemplo, symbole date). Cada um pl.DataFrametem um número de colunas adicionais, que não são importantes para a tarefa real.

As symbolcolunas têm exatamente o mesmo conteúdo (os strvalores diferentes existem em cada dataframe). As datecolunas são um pouco diferentes na forma como não têm exatamente as mesmas datas em cada pl.DataFrame.

A tarefa real é encontrar as datas comuns por agrupamento (ou seja, symbol) e filtrar cada uma pl.DataFrameadequadamente.

Aqui estão três exemplos 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        │
└────────┴────────────┴──────────┘

Agora, o primeiro passo seria encontrar as datas comuns para cada symbol.
AAPL: ["2023-01-02", "2023-01-03", "2023-01-04"]
GOOGL:["2023-01-03", "2023-01-04"]

Isso significa que cada um pl.DataFrameprecisa ser filtrado adequadamente. O resultado esperado se parece com isso:

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        │
└────────┴────────────┴──────────┘

Tenho uma pl.DataFramecoluna contendo listas como esta:

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] │
└────────┴────────────┘

Além disso, tenho uma lista regular de pythonweights = [0.3, 0.7]

Qual é uma maneira eficiente de multiplicar pl.col("roc")por weightsde modo que o primeiro e o segundo elemento da coluna sejam multiplicados pelo primeiro e segundo elemento de weights, respectivamente?

A saída esperada é assim:

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]
└────────┴────────────┘──────────────┘

Considere ter dois pl.DataFrames com esquema idêntico. Uma das colunas tem 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   │
└──────────┴───────┘

Se eu tentar fazer algo simples pl.concat([df1, df2]), recebo o seguinte erro:

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

Você pode contornar esse problema "ampliando" as enumerações assim:

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   │
└──────────┴───────┘

Acho que existe uma maneira mais pythonica de fazer isso?

Tenho um simples pl.DataFramecom várias colunas que contêm apenas valores booleanos.

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 │
└───────┴───────┴───────┘

Preciso adicionar outra coluna que contenha listas de comprimento variável. Uma lista em qualquer linha individual deve conter o nome da coluna onde os valores das colunas S1, s2, e s3têm um Truevalor.

Aqui está o que realmente estou procurando:

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"]       │
└───────┴───────┴───────┴──────────────┘

Preciso calcular classificações transversais em vários títulos de negociação. Considere o seguinte pl.DataFrameem formato longo (organizado). Ele compreende três símbolos diferentes com preços respectivos, onde cada símbolo também tem um calendário de negociação dedicado (ou seja, local).

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  │
└─────────┴────────────┴───────┘

O primeiro passo é calcular os retornos periódicos usando pct_changee posteriormente usando pivotpara alinhar os símbolos por data.

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     │
└────────────┴──────────┴──────────┴──────────┘

O próximo passo é usar concat_listo create listpara calcular as classificações por linha (decrescente, ou seja, o maior retorno obtém a classificação 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]       │
└────────────┴──────────┴──────────┴──────────┴────────────────────┘

Agora estamos finalmente chegando à pergunta real:
Eu gostaria de desfazer o pivot ranksnovamente e produzir um dataframe organizado. Estou procurando pelas seguintes colunas: symbol, date, return, e rank. Eu estava pensando em criar três novas colunas (basicamente usando explodepara descompactar a lista, mas isso criará apenas novas linhas em vez de colunas).

Além disso, estou pensando se preciso fazer pivot dfem primeiro lugar ou se há uma maneira melhor de operar diretamente no original dfem formato tidy? Na verdade, estou procurando desempenho, pois dfpoderia ter milhões de linhas.

Eu tenho dois pl.DataFrames:

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 │
└────────┴──────────────┴────────────┴────────────┘

Preciso filtrar os preços de df1para cada grupo com as respectivas datas de df2. Preciso incorporar todas as colunas do tipo date. O número dessas colunas em df2pode não ser fixo.

Estou procurando o seguinte resultado:

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     │
└────────┴────────────┴───────┘

Eu estava pensando em filtrar df1por symbole então fazer uma operação de junção para cada datecoluna individual de df2. Eu então concatenaria os dataframes resultantes. No entanto, provavelmente há uma solução muito mais elegante.

Tenho pl.DataFrameuma coluna que compreende listas com inteiros. Preciso afirmar que cada inteiro consecutivo está aparecendo duas vezes em uma fileira no máximo.

Por exemplo, uma lista contendo [1,1,0,-1,1]estaria OK, já que o número 1 aparece no máximo duas vezes seguidas (os dois primeiros elementos, seguidos por um zero).

Esta lista deve levar a uma afirmação falha: [1,1,1,0,-1]o número 1aparece três vezes seguidas.

Aqui está um exemplo de brinquedo, onde isso row2deve levar a uma afirmação falha.

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] │
└───────────────┘

Considere o seguinte 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    │
└────────┴────────┴───────┘

Agora preciso agrupar o dataframe symbole verificar se a primeira linha de cada grupo da coluna signalnão é igual a 0 (zero). Se for igual a True, preciso substituir a célula correspondente na coluna tradepelo valor na célula em signal.

Aqui está o que estou realmente procurando:

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    │
└────────┴────────┴───────┘

Considere o seguinte 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]    │
└────────┴───────────┘

Agora, preciso dividir o dataframe em dois pedaços de comprimento 5 ( chunk_size) agrupados pela symbolcoluna. A coluna start_idxindica as linhas para iniciar o bloco em cada grupo. Ou seja, o grupo A será dividido em dois pedaços de comprimento 5 começando nas linhas 0 e 5, enquanto os pedaços do grupo B começam nas linhas 0 e 3. Finalmente, todos os pedaços precisam ser concatenados axis=0, onde uma nova coluna split_idxindica onde a divisão está vindo.

Aqui está o que estou procurando:

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    │
└───────────┴────────┴─────────────────────┴──────┘

Tenha em mente que a lista na coluna start_idxpode ter comprimento variável para cada linha individual. O comprimento de cada lista determina o número de pedaços para cada grupo.

Considere o seguinte quadro de dados.

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

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

Digamos que eu tenha uma lista de tuplas, onde o primeiro valor representa o índice inicial e o segundo valor um valor de comprimento (conforme usado em pl.DataFrame.slice). Isso pode ser assim:

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

Agora, qual é uma boa maneira de fatiar/extrair dois pedaços de df, em que a primeira fatia começa na linha 1 e tem comprimento 2, enquanto a segunda parte começa na linha 5 e tem comprimento 3.

Aqui está o que estou procurando:

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

Considere o seguinte índice múltiplo pd.DataFrameque possui vários valores ausentes.

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

Como posso espremer as linhas o máximo possível? Estou procurando o seguinte resultado:

                         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