Em Polars / pandas / PyArrow, posso instanciar um objeto de um dict, por exemplo
In [12]: pl.DataFrame({'a': [1,2,3], 'b': [4,5,6]})
Out[12]:
shape: (3, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═════╪═════╡
│ 1 ┆ 4 │
│ 2 ┆ 5 │
│ 3 ┆ 6 │
└─────┴─────┘
Existe uma maneira de fazer isso no DuckDB, sem passar pelo pandas / pyarrow / etc.?
Diga que eu tenho
import duckdb
rel = duckdb.sql('select * from values (1, 4), (1, 5), (2, 6) df(a, b)')
rel
Out[3]:
┌───────┬───────┐
│ a │ b │
│ int32 │ int32 │
├───────┼───────┤
│ 1 │ 4 │
│ 1 │ 5 │
│ 2 │ 6 │
└───────┴───────┘
Posso agrupar por a e encontrar a média de 'b' fazendo:
rel.aggregate(
[duckdb.FunctionExpression('mean', duckdb.ColumnExpression('b'))],
group_expr='a',
)
┌─────────┐
│ mean(b) │
│ double │
├─────────┤
│ 4.5 │
│ 6.0 │
└─────────┘
que funciona maravilhosamente
Existe uma maneira semelhante de criar uma agregação "n_unique"? Estou procurando algo como
rel.aggregate(
[duckdb.FunctionExpression('count_distinct', duckdb.ColumnExpression('b'))],
group_expr='a',
)
mas isso não existe. Tem algo que exista?
Diga que eu tenho
data = {'id': [1, 1, 1, 2, 2, 2],
'd': [1, 2, 3, 1, 2, 3],
'sales': [1, 4, 2, 3, 1, 2]}
Quero calcular uma soma contínua com janela de 2 particionada por 'id' ordenada por 'd'
Usando SQL eu posso fazer:
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 │
└───────┴───────┴───────┴───────────────┘
Isso funciona muito bem, mas como posso fazer isso usando a API Relacional do Python?
Eu cheguei até aqui
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)'
)
o que dá
┌───────────────────────────────────────────────────────────────────────────────────────┐
│ sum(sales) OVER (PARTITION BY id ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) │
│ int128 │
├───────────────────────────────────────────────────────────────────────────────────────┤
│ 3 │
│ 4 │
│ 3 │
│ 1 │
│ 5 │
│ 6 │
└───────────────────────────────────────────────────────────────────────────────────────┘
Isso é próximo, mas não está totalmente correto. Como faço para que o nome da última coluna seja rolling_sales?
Digamos que eu tenha:
import pyarrow as pa
arr = pa.array([1, 3, 2, 2, 1, 3])
Gostaria de substituir os valores de acordo com {1: 'one', 2: 'two', 3: 'three'}e terminar com:
<pyarrow.lib.LargeStringArray object at 0x7f8dd0b3c820>
[
"one",
"three",
"two",
"two",
"one",
"three"
]
Posso fazer isso através do 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"
]
Existe uma maneira de fazer isso apenas com o PyArrow?
Diga que eu tenho
In [3]: import pyarrow as pa
In [4]: ca = pa.chunked_array([[1,2,3], [4,5,6]])
Gostaria de extrair elementos [1, 4, 2]e terminar com
<pyarrow.lib.Int64Array object at 0x7f6eb43c2d40>
[
2,
5,
3
]
como se eu estivesse fazendo indexação no estilo NumPy
Digamos que eu tenha:
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],
}
Gostaria de adicionar uma coluna com uma média móvel com tamanho de janela 2, com min_periods=2, sobre'id'
Em Polars, eu posso fazer:
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 │
└─────┴─────┴───────┴───────────────┘
Qual é o equivalente do DuckDB? Eu tentei
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')
mas pegue
┌─────────┬───────┬───────┬───────────────┐
│ 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 │
└─────────┴───────┴───────┴───────────────┘
Isso é muito próximo, mas o duckdb ainda calcula a média móvel quando há apenas um único valor na janela. Como posso replicar o min_periods=2comportamento (padrão) do Polars?
Em Polars, posso usar zip_widthpara tirar valores de s1ou s2de acordo com uma máscara:
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
]
Como posso fazer isso com PyArrow? Eu tentei pyarrow.compute.replace_with_mask, mas funciona de maneira diferente:
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
]
Como replicar zip_withno PyArrow?
Diga que eu tenho
In [22]: import pyarrow as pa
In [23]: t = pa.table({'a': ['one', 'two', 'three']})
e gostaria de acrescentar '_frobenius'a cada elemento de'a'
Resultado esperado:
pyarrow.Table
a: string
----
a: [["one_frobenius","two_frobenius","three_frobenius"]]
Aqui está meu exemplo:
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
Se df1fosse derivado de dfwith copy=False, então eu esperava que uma modificação no local df1também afetasse df. Mas isso não acontece. Por que?
Estou usando o pandas versão 2.2.1, sem opções (por exemplo, copiar na gravação) habilitadas