Início / coding / Perguntas / 78164251
Accepted
HavelTheGreat
Asked: 2024-03-15 09:38:17 +0800 CST

Dividindo cada coluna no dataframe Polars por escalar específico da coluna de outro dataframe

  • 772

Polars noob, dado um m x ndataframe Polars dfe um 1 x ndataframe Polars de escalares, quero dividir cada coluna dfpelo escalar correspondente no outro quadro.

import numpy as np
import polars as pl

cols = list('abc')
df = pl.DataFrame(np.linspace(1, 9, 9).reshape(3, 3),
                  schema=cols)
scalars = pl.DataFrame(np.linspace(1, 3, 3)[:, None],
                       schema=cols)

In [13]: df
Out[13]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
│ 4.0 ┆ 5.0 ┆ 6.0 │
│ 7.0 ┆ 8.0 ┆ 9.0 │
└─────┴─────┴─────┘

In [14]: scalars
Out[14]: 
shape: (1, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
└─────┴─────┴─────┘

Posso fazer isso facilmente no Pandas, conforme mostrado abaixo, delegando à transmissão NumPy, mas queria saber qual a melhor maneira de fazer isso sem ir e voltar entre as representações Polars/Pandas.

In [16]: df.to_pandas() / scalars.to_numpy()
Out[16]: 
     a    b    c
0  1.0  1.0  1.0
1  4.0  2.5  2.0
2  7.0  4.0  3.0

Encontrei esta pergunta semelhante em que a constante escalar já é uma linha no quadro original, mas não vejo como aproveitar uma linha de outro quadro.

O melhor que consegui até agora foi combinar as molduras e fazer algumas... coisas horríveis :D

In [31]: (pl.concat([df, scalars])
    ...:    .with_columns(pl.all() / pl.all().tail(1))
    ...:    .head(-1))
Out[31]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 1.0 ┆ 1.0 │
│ 4.0 ┆ 2.5 ┆ 2.0 │
│ 7.0 ┆ 4.0 ┆ 3.0 │
└─────┴─────┴─────┘
python

2 respostas

  1. Best Answer

    Acho que você descobriu uma solução única/interessante e inteligente. Considere também apenas iterar nas colunas:

    df.select(column / scalars[column.name] for column in df.iter_columns())

    ou

    df.select(pl.col(k) / scalars[k] for k in df.columns)

    ou

    df.with_columns(pl.col(k).truediv(scalars[k]) for k in df.columns)
    • 3

  2. Eu não tinha certeza se isso não seria possível, mas tentei e a aritmética simples realmente funciona, se você colocar os quadros no mesmo formato. Primeiro, use Expr.repeat_by()e depois Expr.list.explode()liste em linhas:

    python

df / scalars.select(pl.all().repeat_by(len(df)).explode())

┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 1.0 ┆ 1.0 │
│ 4.0 ┆ 2.5 ┆ 2.0 │
│ 7.0 ┆ 4.0 ┆ 3.0 │
└─────┴─────┴─────┘

    Além disso, aparentemente você pode usar operações aritméticas entre DataFrame()e Series(), mas parece que você precisa transpose()antes DataFramede fazer isso, porque é feito por colunas (a primeira coluna de DataFrameé dividida pelo primeiro valor de Seriese assim por diante):

    df.transpose()

┌──────────┬──────────┬──────────┐
│ column_0 ┆ column_1 ┆ column_2 │
│ ---      ┆ ---      ┆ ---      │
│ f64      ┆ f64      ┆ f64      │
╞══════════╪══════════╪══════════╡
│ 1.0      ┆ 4.0      ┆ 7.0      │
│ 2.0      ┆ 5.0      ┆ 8.0      │
│ 3.0      ┆ 6.0      ┆ 9.0      │
└──────────┴──────────┴──────────┘

scalars.transpose().to_series()

[
    1.0
    2.0
    3.0
]


(df.transpose() / scalars.transpose().to_series())
.transpose(column_names=df.columns)

┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 1.0 ┆ 1.0 │
│ 4.0 ┆ 2.5 ┆ 2.0 │
│ 7.0 ┆ 4.0 ┆ 3.0 │
└─────┴─────┴─────┘

    Testei rapidamente o desempenho em DataFrames um pouco maiores e todas as soluções propostas parecem ter velocidade semelhante (na minha máquina):

    %timeit 'df.transpose() / scalars.transpose().to_series()).transpose(column_names=df.columns))'
11.4 ns ± 0.892 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)

%timeit 'df / scalars.select(pl.all().repeat_by(len(df)).explode())'
11.7 ns ± 0.992 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)

%timeit 'pl.concat([df, scalars]).with_columns(pl.all() / pl.all().tail(1)).head(-1))'
11.5 ns ± 0.369 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)

%timeit 'df.select(column / scalars[column.name] for column in df.iter_columns())'
11.2 ns ± 0.522 ns per loop (mean ± std. dev. of 7 runs, 100,000,000 loops each)
    • 1

relate perguntas