Accueil›Blog›Test technique Rust pour la data : extensions Python, PyO3, performance

Guide recrutement data

Test technique Rust pour la data : extensions Python, PyO3, performance

Rust est de plus en plus utilisé dans l écosystème data (Polars, DataFusion, Lance). En entretien, un Data Engineer qui comprend pourquoi et comment Rust accélère Python se distingue.

Data Builder·Juin 2025·6 min de lecture·Data Engineer

Sommaire

Rust dans l écosystème data
PyO3 : extensions Python en Rust
Exemple concret
Quand utiliser Rust
Rust dans Polars
Alternatives à Rust
Grille

1Pourquoi Rust dans l écosystème data

Question discriminante

Quels outils data majeurs sont écrits en Rust ? Pourquoi ce choix ?

Polars — DataFrame library 5-50x plus rapide que pandas. Rust permet le multi-threading sans GIL
DataFusion — moteur de requêtes SQL vectorisé en Rust. Base de DuckDB Cloud, Delta Lake 4.0
Lance — format de fichier columnar pour le ML (vecteurs, images). Optimisé pour les embeddings
Pourquoi Rust — performance C sans garbage collector, sécurité mémoire au compile time, parallélisme sans data races
GIL Python — le Global Interpreter Lock empêche le vrai multi-threading Python. Rust contourne cette limite

2PyO3 : appeler du Rust depuis Python

Question discriminante

Comment créez-vous une extension Python en Rust avec PyO3 ?

// Cargo.toml
[dependencies]
pyo3 = { version = '0.20', features = ['extension-module'] }

[lib]
crate-type = ['cdylib']

// src/lib.rs
use pyo3::prelude::*;

// Fonction Rust appelable depuis Python
#[pyfunction]
fn fast_hash_many(values: Vec) -> Vec {
    // Traitement parallèle avec rayon
    use rayon::prelude::*;
    values.par_iter()
        .map(|v| format!("{:x}", md5::compute(v.as_bytes())))
        .collect()
}

#[pymodule]
fn fast_data(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(fast_hash_many, m)?)?;
    Ok(())
}

## Python
import fast_data

results = fast_data.fast_hash_many(['email@example.com', 'autre@example.com'])
# 50-100x plus rapide que le hashage Python pur pour de gros volumes

3Cas concret : accélérer un calcul Python

Question discriminante

Quand a-t-il du sens d écrire une extension Rust pour accélérer un pipeline Python ?

Calcul intensif en boucle — parcourir 100M de lignes avec logique complexe en Python pur est très lent. Rust natif 50-100x plus rapide
Déduplication sur gros volumes — probabilistic matching sur des millions d enregistrements. Splink (Python) utilise Rust pour le coeur de calcul
Parsers custom — parser des formats binaires propriétaires. Rust offre performance et sécurité mémoire
À ne pas faire en Rust — logique SQL (utiliser DuckDB), transformations de DataFrames (utiliser Polars), agrégations simples (pandas ou DuckDB)

4Quand choisir Rust vs Cython vs Numba

Question discriminante

Quelles alternatives à Rust pour accélérer le Python ?

Outil	Courbe	Gains	Cas d usage
Rust + PyO3	Élevée	50-100x	Performance critique, code réutilisable
Cython	Moyenne	5-50x	Code Python existant à accélérer
Numba JIT	Faible	10-100x	Boucles numériques simples (NumPy-like)
C Extension (ctypes)	Élevée	50-100x	Interfacer avec des libs C existantes
Polars (Rust natif)	Faible	5-50x vs pandas	Transformations de DataFrames

5Polars : tirer parti de Rust sans l écrire

Question discriminante

Comment exploitez-vous les capacités Rust de Polars sans écrire de Rust ?

import polars as pl

# Polars utilise Rust en interne pour :
# 1. Parallélisme automatique
df = pl.scan_parquet('data/**/*.parquet')
    .filter(pl.col('amount') > 100)
    .group_by('region')
    .agg(pl.col('amount').sum())
    .collect()  # Rust parallélise automatiquement

# 2. Extensions Rust via plugins
import polars_plugin  # hypothétique

# 3. Lazy API = Rust query optimizer
plan = df.lazy().explain()  # voir le plan d exécution Rust

# 4. Apache Arrow : zéro-copy entre Polars (Rust) et Python
arrow_table = df.to_arrow()  # zero-copy
pandas_df = df.to_pandas()   # via Arrow, très efficace

6Alternatives modernes à Rust pour la data

Question discriminante

Quels autres langages ou outils offrent des performances Rust-like pour la data ?

DataFusion — moteur SQL vectorisé en Rust, accessible via Python et R. Plus rapide que Spark pour les petits clusters
Lance format — format columnar Rust optimisé pour les embeddings et les données ML. Alternative à Parquet pour le ML
Daft — DataFrame library en Rust avec API Python. Alternative à Spark pour les petits-moyens volumes
Going via Julia — pour le calcul scientifique intensif, Julia compile vers des performances proches de Rust mais avec une syntaxe mathématique

7Grille par niveau

Niveau	Maitrise	Signal GO	NO-GO
Senior	Comprend pourquoi Rust est utilisé en data, tire parti de Polars	Explique le GIL et pourquoi Rust le contourne, utilise Polars intelligemment	Ne sait pas ce qu est PyO3
Expert	A écrit du code Rust, a créé une extension PyO3	A une extension Rust en production, compare les options d accélération	N a jamais regardé le code Rust de Polars

Vous recrutez un Data Engineer performance-oriented ?

Premier entretien gratuit. Rapport GO/NO-GO sous 48h.

Tester gratuitement Reserver un appel