polars
Python Polars 1.14.0
Documentação : Python - Rust - Node.js - R | StackOverflow : Python - Rust - Node.js - R | Guia do usuário | Discórdia
Polars é uma interface DataFrame baseada em um OLAP Query Engine implementado em Rust usando o formato Apache Arrow Columnar como modelo de memória.
Para saber mais, leia o guia do usuário.
>> > import polars as pl
>> > df = pl . DataFrame (
... {
... "A" : [ 1 , 2 , 3 , 4 , 5 ],
... "fruits" : [ "banana" , "banana" , "apple" , "apple" , "banana" ],
... "B" : [ 5 , 4 , 3 , 2 , 1 ],
... "cars" : [ "beetle" , "audi" , "beetle" , "beetle" , "beetle" ],
... }
... )
# embarrassingly parallel execution & very expressive query language
>> > df . sort ( "fruits" ). select (
... "fruits" ,
... "cars" ,
... pl . lit ( "fruits" ). alias ( "literal_string_fruits" ),
... pl . col ( "B" ). filter ( pl . col ( "cars" ) == "beetle" ). sum (),
... pl . col ( "A" ). filter ( pl . col ( "B" ) > 2 ). sum (). over ( "cars" ). alias ( "sum_A_by_cars" ),
... pl . col ( "A" ). sum (). over ( "fruits" ). alias ( "sum_A_by_fruits" ),
... pl . col ( "A" ). reverse (). over ( "fruits" ). alias ( "rev_A_by_fruits" ),
... pl . col ( "A" ). sort_by ( "B" ). over ( "fruits" ). alias ( "sort_A_by_B_by_fruits" ),
... )
shape : ( 5 , 8 )
┌──────────┬──────────┬──────────────┬─────┬─────────────┬─────────────┬─────────────┬─────────────┐
│ fruits ┆ cars ┆ literal_stri ┆ B ┆ sum_A_by_ca ┆ sum_A_by_fr ┆ rev_A_by_fr ┆ sort_A_by_B │
│ - - - ┆ - - - ┆ ng_fruits ┆ - - - ┆ rs ┆ uits ┆ uits ┆ _by_fruits │
│ str ┆ str ┆ - - - ┆ i64 ┆ - - - ┆ - - - ┆ - - - ┆ - - - │
│ ┆ ┆ str ┆ ┆ i64 ┆ i64 ┆ i64 ┆ i64 │
╞══════════╪══════════╪══════════════╪═════╪═════════════╪═════════════╪═════════════╪═════════════╡
│ "apple" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 7 ┆ 4 ┆ 4 │
│ "apple" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 7 ┆ 3 ┆ 3 │
│ "banana" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 8 ┆ 5 ┆ 5 │
│ "banana" ┆ "audi" ┆ "fruits" ┆ 11 ┆ 2 ┆ 8 ┆ 2 ┆ 2 │
│ "banana" ┆ "beetle" ┆ "fruits" ┆ 11 ┆ 4 ┆ 8 ┆ 1 ┆ 1 │
└──────────┴──────────┴──────────────┴─────┴─────────────┴─────────────┴─────────────┴─────────────┘ >> > df = pl . scan_csv ( "docs/assets/data/iris.csv" )
>> > ## OPTION 1
>> > # run SQL queries on frame-level
>> > df . sql ( """
... SELECT species,
... AVG(sepal_length) AS avg_sepal_length
... FROM self
... GROUP BY species
... """ ). collect ()
shape : ( 3 , 2 )
┌────────────┬──────────────────┐
│ species ┆ avg_sepal_length │
│ - - - ┆ - - - │
│ str ┆ f64 │
╞════════════╪══════════════════╡
│ Virginica ┆ 6.588 │
│ Versicolor ┆ 5.936 │
│ Setosa ┆ 5.006 │
└────────────┴──────────────────┘
>> > ## OPTION 2
>> > # use pl.sql() to operate on the global context
>> > df2 = pl . LazyFrame ({
... "species" : [ "Setosa" , "Versicolor" , "Virginica" ],
... "blooming_season" : [ "Spring" , "Summer" , "Fall" ]
...})
>> > pl . sql ( """
... SELECT df.species,
... AVG(df.sepal_length) AS avg_sepal_length,
... df2.blooming_season
... FROM df
... LEFT JOIN df2 ON df.species = df2.species
... GROUP BY df.species, df2.blooming_season
... """ ). collect ()Os comandos SQL também podem ser executados diretamente do seu terminal usando a CLI do Polars:
# run an inline SQL query
> polars -c " SELECT species, AVG(sepal_length) AS avg_sepal_length, AVG(sepal_width) AS avg_sepal_width FROM read_csv('docs/assets/data/iris.csv') GROUP BY species; "
# run interactively
> polars
Polars CLI v0.3.0
Type .help for help.
> SELECT species, AVG(sepal_length) AS avg_sepal_length, AVG(sepal_width) AS avg_sepal_width FROM read_csv( ' docs/assets/data/iris.csv ' ) GROUP BY species ;Consulte o repositório Polars CLI para obter mais informações.
Polars é muito rápido. Na verdade, é uma das soluções de melhor desempenho disponíveis. Veja os resultados dos benchmarks PDS-H.
Polars também é muito leve. Ele vem com zero dependências obrigatórias, e isso aparece nos tempos de importação:
Se você tiver dados que não cabem na memória, o mecanismo de consulta do Polars será capaz de processar sua consulta (ou partes dela) em streaming. Isso reduz drasticamente os requisitos de memória, para que você possa processar seu conjunto de dados de 250 GB em seu laptop. Colete com collect(streaming=True) para executar o streaming de consulta. (Isso pode ser um pouco mais lento, mas ainda é muito rápido!)
Instale a versão mais recente do Polars com:
pip install polars Também temos um pacote conda ( conda install -c conda-forge polars ), porém pip é a forma preferida de instalar Polars.
Instale o Polars com todas as dependências opcionais.
pip install ' polars[all] 'Você também pode instalar um subconjunto de todas as dependências opcionais.
pip install ' polars[numpy,pandas,pyarrow] 'Consulte o Guia do usuário para obter mais detalhes sobre dependências opcionais
Para ver a versão atual do Polars e uma lista completa de suas dependências opcionais, execute:
pl . show_versions ()Os lançamentos acontecem com bastante frequência (semanalmente/a cada poucos dias) no momento, portanto, atualizar o Polars regularmente para obter as correções de bugs/recursos mais recentes pode não ser uma má ideia.
Você pode obter a versão mais recente de crates.io ou, se quiser usar os recursos/melhorias de desempenho mais recentes, aponte para o branch main deste repositório.
polars = { git = " https://github.com/pola-rs/polars " , rev = " <optional git tag> " } Requer versão Rust >=1.80 .
Quer contribuir? Leia nosso guia de contribuição.
Se você deseja um lançamento inovador ou desempenho máximo, você deve compilar Polars a partir do código-fonte.
Isso pode ser feito seguindo as seguintes etapas em sequência:
pip install maturincd py-polars e escolha um dos seguintes:make build , binário lento com asserções e símbolos de depuração, tempos de compilação rápidosmake build-release , binário rápido sem asserções de depuração, símbolos de depuração mínimos, longos tempos de compilaçãomake build-nodebug-release , igual ao build-release, mas sem nenhum símbolo de depuração, um pouco mais rápido para compilarmake build-debug-release , igual ao build-release mas com símbolos de depuração completos, um pouco mais lento para compilarmake build-dist-release , binário mais rápido, tempos de compilação extremos Por padrão, o binário é compilado com otimizações ativadas para uma CPU moderna. Especifique LTS_CPU=1 com o comando se sua CPU for mais antiga e não suportar, por exemplo, AVX2.
Observe que a caixa Rust que implementa as ligações Python é chamada de py-polars para distinguir das próprias polars da caixa Rust agrupadas. No entanto, tanto o pacote Python quanto o módulo Python são nomeados polars , então você pode pip install polars e import polars .
Estender Polars com UDFs compilados em Rust é fácil. Expomos extensões PyO3 para estruturas de dados DataFrame e Series . Veja mais em https://github.com/pola-rs/pyo3-polars.
Você espera mais de 2^32 (~4,2 bilhões) linhas? Compile Polars com o sinalizador de recurso bigidx ou, para usuários de Python, instale pip install polars-u64-idx .
Não use isso a menos que você atinja o limite da linha, pois a construção padrão do Polars é mais rápida e consome menos memória.
Você deseja que o Polars seja executado em uma CPU antiga (por exemplo, anterior a 2011) ou em uma versão x86-64 do Python no Apple Silicon no Rosetta? Instale pip install polars-lts-cpu . Esta versão do Polars é compilada sem recursos de destino AVX.
