Início / coding / Perguntas / 78816652
Accepted
Phil-ZXX
Asked: 2024-07-31 21:33:07 +0800 CST

Multiplique colunas polares do tipo numérico pelo tipo de objeto (que suporta __mul__)

  • 772

Eu tenho o seguinte código.

import polars as pl

class Summary:
    def __init__(self, value: float, origin: str):
        self.value  = value
        self.origin = origin

    def __repr__(self) -> str:
        return f'Summary({self.value},{self.origin})'

    def __mul__(self, x: float | int) -> 'Summary':
        return Summary(self.value * x, self.origin)

    def __rmul__(self, x: float | int) -> 'Summary':
        return self * x

mapping = {
    'CASH':  Summary( 1, 'E'),
    'ITEM':  Summary(-9, 'A'),
    'CHECK': Summary(46, 'A'),
}

df = pl.DataFrame({'quantity': [7, 4, 10], 'type': mapping.keys(), 'summary': mapping.values()})

O dataframe dftem a seguinte aparência.

shape: (3, 3)
┌──────────┬───────┬───────────────┐
│ quantity ┆ type  ┆ summary       │
│ ---      ┆ ---   ┆ ---           │
│ i64      ┆ str   ┆ object        │
╞══════════╪═══════╪═══════════════╡
│ 7        ┆ CASH  ┆ Summary(1,E)  │
│ 4        ┆ ITEM  ┆ Summary(-9,A) │
│ 10       ┆ CHECK ┆ Summary(46,A) │
└──────────┴───────┴───────────────┘

Especialmente, a summarycoluna contém um Summaryobjeto de classe, que suporta multiplicação. Agora, gostaria de multiplicar esta coluna pela quantitycoluna.

No entanto, a abordagem ingénua levanta um erro.

df.with_columns(pl.col('quantity').mul(pl.col('summary')).alias('qty_summary'))

SchemaError: failed to determine supertype of i64 and object

Existe uma maneira de multiplicar essas colunas?

python

2 respostas

  1. Best Answer

    Lembre-se de que o Polars foi projetado para que os cálculos sejam executados em Rust, não em Python, onde é 1000x mais rápido. Se você deseja executar operações Python, você perde muitos benefícios de usar Polars em primeiro lugar.

    Mas, felizmente, o Polars tem um recurso muito interessante que é relevante aqui, que é o processamento “nativo” de arquivos dataclasses.

    import polars as pl
from dataclasses import dataclass


@dataclass
class Summary:
    value: float
    origin: str

    def __mul__(self, x: float | int) -> "Summary":
        return Summary(self.value * x, self.origin)

    def __rmul__(self, x: float | int) -> "Summary":
        return self * x


mapping = {
    "CASH": Summary(1, "E"),
    "ITEM": Summary(-9, "A"),
    "CHECK": Summary(46, "A"),
}

df = pl.DataFrame(
    {
        "quantity": [7, 4, 10],
        "type": mapping.keys(),
        "summary": mapping.values(),
    }
)

df

    Porque Summaryé um dataclass, você 1. não precisa __init__de e __repr__(eles vêm de graça) e 2. não precisa fazer nada especial para que os Polars os estruturem.

    shape: (3, 3)
┌──────────┬───────┬────────────┐
│ quantity ┆ type  ┆ summary    │
│ ---      ┆ ---   ┆ ---        │
│ i64      ┆ str   ┆ struct[2]  │
╞══════════╪═══════╪════════════╡
│ 7        ┆ CASH  ┆ {1.0,"E"}  │
│ 4        ┆ ITEM  ┆ {-9.0,"A"} │
│ 10       ┆ CHECK ┆ {46.0,"A"} │
└──────────┴───────┴────────────┘

    Agora você pode simplesmente fazer operações regulares de estrutura Polars:

    df.with_columns(
    qty_summary=pl.struct(
        pl.col("summary").struct.field("value") * pl.col("quantity"),
        pl.col("summary").struct.field("origin"),
    )
)
    • 4

  2. Você mencionou nos comentários que gostaria de poder multiplicar determinados campos da Summarycoluna por outra coluna.

    Talvez como sugestão você possa armazenar seus dados como uma estrutura:

    df = pl.DataFrame({
    "type": ["CASH","ITEM","CHECK"], 
    "summary": [{'value':  1.0, 'origin': 'E'}, {'value': -9.0, 'origin': 'A'},  {'value': 46.0, 'origin': 'A'}],
    "quantity": [7,4,10]
})

┌───────┬────────────┬──────────┐
│ type  ┆ summary    ┆ quantity │
│ ---   ┆ ---        ┆ ---      │
│ str   ┆ struct[2]  ┆ i64      │
╞═══════╪════════════╪══════════╡
│ CASH  ┆ {1.0,"E"}  ┆ 7        │
│ ITEM  ┆ {-9.0,"A"} ┆ 4        │
│ CHECK ┆ {46.0,"A"} ┆ 10       │
└───────┴────────────┴──────────┘

    E defina separadamente uma lista de campos que você deseja que sejam afetados. Você pode usar with_fields()para multiplicar alguns dos campos da estrutura:

    fields_to_multiply = ["value"]

df.with_columns(
    pl.col.summary.struct.with_fields(
        pl.field(fields_to_multiply) * pl.col.quantity
    )
)


┌───────┬─────────────┬──────────┐
│ type  ┆ summary     ┆ quantity │
│ ---   ┆ ---         ┆ ---      │
│ str   ┆ struct[2]   ┆ i64      │
╞═══════╪═════════════╪══════════╡
│ CASH  ┆ {7.0,"E"}   ┆ 7        │
│ ITEM  ┆ {-36.0,"A"} ┆ 4        │
│ CHECK ┆ {460.0,"A"} ┆ 10       │
└───────┴─────────────┴──────────┘
    • 1

relate perguntas