主页 / user-4451315

ignoring_gravity's questions

Martin Hope
ignoring_gravity
Asked: 2024-11-11 02:55:19 +0800 CST
  • 8

说我有

data = {'id': [1, 1, 1, 2, 2, 2],
 'd': [1, 2, 3, 1, 2, 3],
 'sales': [1, 4, 2, 3, 1, 2]}

我想计算一个滚动总和，窗口为 2，按 'id' 分区，按 'd' 排序

使用 SQL 我可以做到：

duckdb.sql("""
select *, sum(sales) over w as rolling_sales
from df
window w as (partition by id order by d rows between 1 preceding and current row)
""")
Out[21]:
┌───────┬───────┬───────┬───────────────┐
│  id   │   d   │ sales │ rolling_sales │
│ int64 │ int64 │ int64 │    int128     │
├───────┼───────┼───────┼───────────────┤
│     1 │     1 │     1 │             1 │
│     1 │     2 │     4 │             5 │
│     1 │     3 │     2 │             6 │
│     2 │     1 │     3 │             3 │
│     2 │     2 │     1 │             4 │
│     2 │     3 │     2 │             3 │
└───────┴───────┴───────┴───────────────┘

这很有效，但是我如何使用 Python 关系 API 来实现它呢？

我已经

rel = duckdb.sql('select * from df')
rel.sum(
    'sales',
    projected_columns='*',
    window_spec='over (partition by id order by d rows between 1 preceding and current row)'
)

由此得出

┌───────────────────────────────────────────────────────────────────────────────────────┐
│ sum(sales) OVER (PARTITION BY id ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) │
│                                        int128                                         │
├───────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                     3 │
│                                                                                     4 │
│                                                                                     3 │
│                                                                                     1 │
│                                                                                     5 │
│                                                                                     6 │
└───────────────────────────────────────────────────────────────────────────────────────┘

这很接近，但不太正确 - 我如何获取最后一列的名称rolling_sales？

python
Martin Hope
ignoring_gravity
Asked: 2024-10-21 23:38:33 +0800 CST
  • 5

假设我有：

import pyarrow as pa

arr = pa.array([1, 3, 2, 2, 1, 3])

我想根据{1: 'one', 2: 'two', 3: 'three'}并最终替换值：

<pyarrow.lib.LargeStringArray object at 0x7f8dd0b3c820>
[
  "one",
  "three",
  "two",
  "two",
  "one",
  "three"
]

我可以通过 Polars 来实现这一点：

In [19]: pl.from_arrow(arr).replace_strict({1: 'one', 2: 'two', 3: 'three'}, return_dtype=pl.String).to_arrow()
Out[19]:
<pyarrow.lib.LargeStringArray object at 0x7f8dd0b3c820>
[
  "one",
  "three",
  "two",
  "two",
  "one",
  "three"
]

有没有办法只用 PyArrow 来完成它？

python
Martin Hope
ignoring_gravity
Asked: 2024-09-05 21:17:09 +0800 CST
  • 9

假设我有：

data = {
    'id': ['a', 'a', 'a', 'b', 'b', 'b', 'b'],
    'd': [1,2,3,0,1,2,3],
    'sales': [5,1,3,4,1,2,3],
}

我想添加一个带有滚动平均值的列，窗口大小为 2 min_periods=2，'id'

在 Polars 中，我可以执行以下操作：

import polars as pl

df = pl.DataFrame(data)
df.with_columns(sales_rolling = pl.col('sales').rolling_mean(2).over('id'))

shape: (7, 4)
┌─────┬─────┬───────┬───────────────┐
│ id  ┆ d   ┆ sales ┆ sales_rolling │
│ --- ┆ --- ┆ ---   ┆ ---           │
│ str ┆ i64 ┆ i64   ┆ f64           │
╞═════╪═════╪═══════╪═══════════════╡
│ a   ┆ 1   ┆ 5     ┆ null          │
│ a   ┆ 2   ┆ 1     ┆ 3.0           │
│ a   ┆ 3   ┆ 3     ┆ 2.0           │
│ b   ┆ 0   ┆ 4     ┆ null          │
│ b   ┆ 1   ┆ 1     ┆ 2.5           │
│ b   ┆ 2   ┆ 2     ┆ 1.5           │
│ b   ┆ 3   ┆ 3     ┆ 2.5           │
└─────┴─────┴───────┴───────────────┘

DuckDB 的对应产品是什么？我试过

import duckdb

duckdb.sql("""
    select
        *,
        mean(sales) over (
            partition by id 
            order by d
            range between 1 preceding and 0 following
        ) as sales_rolling 
    from df
""").sort('id', 'd')

但得到

┌─────────┬───────┬───────┬───────────────┐
│   id    │   d   │ sales │ sales_rolling │
│ varchar │ int64 │ int64 │    double     │
├─────────┼───────┼───────┼───────────────┤
│ a       │     1 │     5 │           5.0 │
│ a       │     2 │     1 │           3.0 │
│ a       │     3 │     3 │           2.0 │
│ b       │     0 │     4 │           4.0 │
│ b       │     1 │     1 │           2.5 │
│ b       │     2 │     2 │           1.5 │
│ b       │     3 │     3 │           2.5 │
└─────────┴───────┴───────┴───────────────┘

这非常接近，但当窗口中只有一个值时，duckdb 仍会计算滚动平均值。我如何复制min_periods=2Polars 的（默认）行为？

python
Martin Hope
ignoring_gravity
Asked: 2024-08-24 17:39:07 +0800 CST
  • 6

在极坐标中，我可以使用从掩码中或根据掩码zip_width获取值：s1s2

In [1]: import polars as pl

In [2]: import pyarrow as pa

In [3]: import pyarrow as pc

In [4]: s1 = pl.Series([1,2,3])

In [5]: mask = pl.Series([True, False, False])

In [6]: s2 = pl.Series([4, 5, 6])

In [7]: s1.zip_with(mask, s2)
Out[7]:
shape: (3,)
Series: '' [i64]
[
        1
        5
        6
]

我该如何使用 PyArrow 来实现这一点？我试过了，pyarrow.compute.replace_with_mask但效果不一样：

In [10]: import pyarrow.compute as pc

In [11]: import pyarrow as pa

In [12]: a1 = pa.array([1,2,3])

In [13]: mask = pa.array([True, False, False])

In [14]: a2 = pa.array([4,5,6])

In [15]: pc.replace_with_mask(a1, pc.invert(mask), a2)
Out[15]:
<pyarrow.lib.Int64Array object at 0x7f69d411afe0>
[
  1,
  4,
  5
]

如何zip_with在 PyArrow 中复制？

python
Martin Hope
ignoring_gravity
Asked: 2024-03-16 15:45:23 +0800 CST
  • 7

这是我的例子：

In [1]: import pandas as pd

In [2]: df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6]})

In [3]: df1 = df.rename(columns={'b': 'b'}, copy=False)

In [4]: df1.isetitem(1, [7,8,9])

In [5]: df
Out[5]:
   a  b
0  1  4
1  2  5
2  3  6

In [6]: df1
Out[6]:
   a  b
0  1  7
1  2  8
2  3  9

如果df1是从dfwith派生的copy=False，那么我预计对 的就地修改df1也会影响df。但事实并非如此。为什么？

我正在使用 pandas 版本 2.2.1，未启用任何选项（例如写入时复制）

python