Librería Polars para Rust: Guía completa

Polars es una librería de alto rendimiento para trabajar con datos en formato DataFrame, escrita en Rust. Ofrece una API familiar para los usuarios de pandas, pero supera significativamente a esta en velocidad y eficiencia de memoria. A diferencia de pandas, que a menudo se topa con las limitaciones de la ejecución monohilo y el consumo de RAM, Polars está diseñado desde cero para funcionar en modo multihilo y utiliza evaluación perezosa (lazy API) para optimizar las consultas.

El objetivo principal de Polars es proporcionar una herramienta para procesar grandes volúmenes de datos (desde cientos de megabytes hasta varios terabytes) en un solo nodo, sin necesidad de recurrir a sistemas distribuidos como Spark. Esto se logra gracias a una gestión eficiente de la memoria (copia cero, uso de Apache Arrow como backend), vectorización de operaciones y paralelización automática. Para los desarrolladores de Rust, Polars no es solo un envoltorio sobre la librería de Python, sino una librería nativa que aprovecha al máximo las capacidades del lenguaje: seguridad de memoria, sistema de tipos y rendimiento.

La librería ofrece dos APIs: Eager (cálculo inmediato) y Lazy (cálculo perezoso). La API Eager es ideal para trabajo interactivo y conjuntos de datos pequeños, cuando necesitas ver el resultado de inmediato. La API Lazy permite construir un plan de consulta que luego se optimiza y ejecuta en una sola pasada, algo crítico para transformaciones complejas y grandes volúmenes de datos. Polars también admite trabajar con CSV, Parquet, JSON, IPC (Arrow) y bases de datos a través de SQL.

Instalación

Para añadir Polars a un proyecto en Rust, debes agregar la dependencia en el archivo Cargo.toml:

[dependencies]
polars = "0.44.0"  # Verifica la versión actual en crates.io

Si necesitas funcionalidades adicionales (como soporte para expresiones regulares en cadenas, trabajo con fechas o integración con SQL), usa las características (features):

[dependencies]
polars = { version = "0.44.0", features = ["lazy", "strings", "dtype-date", "dtype-datetime", "sql", "parquet", "csv"] }

Características principales:

• lazy — API perezosa (imprescindible para trabajo serio)
• strings — métodos para trabajar con cadenas (contains, replace, extract)
• dtype-date, dtype-datetime — soporte para tipos de fecha
• sql — interfaz SQL
• parquet — lectura/escritura de Parquet
• csv — lectura/escritura de CSV
• is_in, rank, moment — métodos adicionales

Después de agregar la dependencia, ejecuta:

cargo build

Inicio rápido

Un ejemplo mínimo funcional para crear un DataFrame y ejecutar una consulta simple:

use polars::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Creamos un DataFrame a partir de vectores
    let df = df! [
        "name" => &["Alice", "Bob", "Charlie"],
        "age" => &[25, 30, 35],
        "salary" => &[50000, 60000, 70000]
    ]?;

    println!("DataFrame original:\n{:?}", df);

    // Filtrado: quiénes tienen más de 28 años
    let filtered = df.clone().lazy()
        .filter(col("age").gt(lit(28)))
        .collect()?;

    println!("Filtrado (edad > 28):\n{:?}", filtered);

    // Agregación: salario promedio
    let avg_salary = df.clone().lazy()
        .select([col("salary").mean().alias("avg_salary")])
        .collect()?;

    println!("Salario promedio:\n{:?}", avg_salary);

    Ok(())
}

Este código crea una tabla con tres columnas, filtra las filas por edad y calcula el salario promedio. Observa el uso de lazy() — incluso para operaciones simples se recomienda