Bibliothèque Polars pour Rust : Guide complet

Polars est une bibliothèque haute performance pour la manipulation de données sous forme de DataFrame, écrite en Rust. Elle offre une API familière aux utilisateurs de pandas, tout en étant nettement plus rapide et économe en mémoire. Contrairement à pandas, qui se heurte souvent aux limites de l'exécution monothread et de la consommation de RAM, Polars a été conçu dès le départ pour le multithreading et utilise le calcul paresseux (lazy API) afin d'optimiser les requêtes.

L'objectif principal de Polars est de fournir un outil capable de traiter de gros volumes de données (de quelques centaines de mégaoctets à plusieurs téraoctets) sur un seul nœud, sans recourir à des systèmes distribués comme Spark. Cela est rendu possible grâce à une gestion efficace de la mémoire (zéro copie, utilisation d'Apache Arrow comme backend), à la vectorisation des opérations et à la parallélisation automatique. Pour les développeurs Rust, Polars n'est pas un simple wrapper autour d'une bibliothèque Python, mais une bibliothèque native qui exploite pleinement les atouts du langage : sécurité mémoire, système de types et performances.

La bibliothèque propose deux API : Eager (calcul immédiat) et Lazy (calcul paresseux). L'API Eager est idéale pour le travail interactif et les petits jeux de données, lorsque vous souhaitez voir le résultat immédiatement. L'API Lazy permet de construire un plan de requête qui est ensuite optimisé et exécuté en une seule passe, ce qui est crucial pour les transformations complexes et les données volumineuses. Polars prend également en charge les formats CSV, Parquet, JSON, IPC (Arrow) et les bases de données via SQL.

Installation

Pour ajouter Polars à un projet Rust, ajoutez la dépendance dans le fichier Cargo.toml :

[dependencies]
polars = "0.44.0"  # Vérifiez la version actuelle sur crates.io

Si vous avez besoin de fonctionnalités supplémentaires (comme la gestion des expressions régulières, des dates, ou l'intégration SQL), utilisez les features :

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

Principales features :

lazy — API paresseuse (recommandée pour un usage sérieux)
strings — méthodes de manipulation de chaînes (contains, replace, extract)
dtype-date, dtype-datetime — prise en charge des types date
sql — interface SQL
parquet — lecture/écriture Parquet
csv — lecture/écriture CSV
is_in, rank, moment — méthodes supplémentaires

Après avoir ajouté la dépendance, exécutez :

cargo build

Premiers pas

Un exemple minimal pour créer un DataFrame et effectuer une requête simple :

use polars::prelude::*;

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

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

    // Filtrage : personnes de plus de 28 ans
    let filtered = df.clone().lazy()
        .filter(col("age").gt(lit(28)))
        .collect()?;

    println!("Filtré (age > 28) :\n{:?}", filtered);

    // Agrégation : salaire moyen
    let avg_salary = df.clone().lazy()
        .select([col("salary").mean().alias("avg_salary")])
        .collect()?;

    println!("Salaire moyen :\n{:?}", avg_salary);

    Ok(())
}

Ce code crée un tableau avec trois colonnes, filtre les lignes par âge et calcule le salaire moyen. Notez l'utilisation de lazy() — même pour des opérations simples, il est recommandé de l'utiliser pour bénéficier de l'optimisation automatique des requêtes.