Suporte upstream incluído

Arquivos de suporte são incluídos em caminhos relativos à skill. Veja UPSTREAM-NOTICE.md para suas fontes fixadas, licenças, hashes e alterações de importação.

Polars

Quando Usar

• Você precisa de um fluxo de trabalho de DataFrame em memória mais rápido que o pandas para dados que ainda cabem na RAM.
• Você está construindo pipelines de ETL, análise ou transformação que se beneficiam da avaliação preguiçosa (lazy evaluation) e execução paralela.
• Você quer operações tabulares baseadas em expressões sobre a semântica do Apache Arrow.

Visão Geral

Polars é uma biblioteca de DataFrame extremamente rápida para Python e Rust construída sobre o Apache Arrow. Trabalhe com a API baseada em expressões do Polars, o framework de avaliação preguiçosa e capacidades de manipulação de dados de alta performance para processamento eficiente de dados, migração do pandas e otimização de pipelines de dados.

Início Rápido

Instalação e Uso Básico

Instale o Polars:

uv pip install polars

Criação e operações básicas de DataFrame:

import polars as pl

# Create DataFrame
df = pl.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["NY", "LA", "SF"]
})

# Select columns
df.select("name", "age")

# Filter rows
df.filter(pl.col("age") > 25)

# Add computed columns
df.with_columns(
    age_plus_10=pl.col("age") + 10
)

Conceitos Principais

Expressões

Expressões são os blocos de construção fundamentais das operações do Polars. Elas descrevem transformações em dados e podem ser compostas, reutilizadas e otimizadas.

Princípios chave:

• Use pl.col("column_name") para referenciar colunas
• Encadeie métodos para construir transformações complexas
• Expressões são preguiçosas e só executam dentro de contextos (select, with_columns, filter, group_by)

Exemplo:

# Expression-based computation
df.select(
    pl.col("name"),
    (pl.col("age") * 12).alias("age_in_months")
)

Avaliação Preguiçosa (Lazy) vs. Imediata (Eager)

Imediata (DataFrame): Operações executam imediatamente

df = pl.read_csv("file.csv")  # Reads immediately
result = df.filter(pl.col("age") > 25)  # Executes immediately

Preguiçosa (LazyFrame): Operações constroem um plano de consulta, otimizado antes da execução

lf = pl.scan_csv("file.csv")  # Doesn't read yet
result = lf.filter(pl.col("age") > 25).select("name", "age")
df = result.collect()  # Now executes optimized query

Quando usar preguiçosa:

• Trabalhando com grandes conjuntos de dados
• Pipelines de consulta complexos
• Quando apenas algumas colunas/linhas são necessárias
• Performance é crítica

Benefícios da avaliação preguiçosa:

• Otimização automática de consulta
• Predicate pushdown (empurrar filtros para baixo)
• Projection pushdown (empurrar seleções de colunas para baixo)
• Execução paralela

Para conceitos detalhados, carregue references/core_concepts.md.

Operações Comuns

Selecionar (Select)

Selecione e manipule colunas:

# Select specific columns
df.select("name", "age")

# Select with expressions
df.select(
    pl.col("name"),
    (pl.col("age") * 2).alias("double_age")
)

# Select all columns matching a pattern
df.select(pl.col("^.*_id$"))

Filtrar (Filter)

Filtre linhas por condições:

# Single condition
df.filter(pl.col("age") > 25)

# Multiple conditions (cleaner than using &)
df.filter(
    pl.col("age") > 25,
    pl.col("city") == "NY"
)

# Complex conditions
df.filter(
    (pl.col("age") > 25) | (pl.col("city") == "LA")
)

Com Colunas (With Columns)

Adicione ou modifique colunas preservando as existentes:

# Add new columns
df.with_columns(
    age_plus_10=pl.col("age") + 10,
    name_upper=pl.col("name").str.to_uppercase()
)

# Parallel computation (all columns computed in parallel)
df.with_columns(
    pl.col("value") * 10,
    pl.col("value") * 100,
)

Agrupar Por (Group By) e Agregações

Agrupe dados e compute agregações:

# Basic grouping
df.group_by("city").agg(
    pl.col("age").mean().alias("avg_age"),
    pl.len().alias("count")
)

# Multiple group keys
df.group_by("city", "department").agg(
    pl.col("salary").sum()
)

# Conditional aggregations
df.group_by("city").agg(
    (pl.col("age") > 30).sum().alias("over_30")
)

Para padrões de operação detalhados, carregue references/operations.md.

Agregações e Funções de Janela

Funções de Agregação

Agregações comuns dentro do contexto group_by:

• pl.len() - contar linhas
• pl.col("x").sum() - somar valores
• pl.col("x").mean() - média
• pl.col("x").min() / pl.col("x").max() - extremos
• pl.first() / pl.last() - primeiros/últimos valores

Funções de Janela com over()

Aplique agregações preservando a contagem de linhas:

# Adiciona estatísticas de grupo a cada linha

…