Dask : traite des millions de lignes quand ta RAM dit stop

Un jour, ton script Pandas tourne comme une horloge. Le lendemain, ton fichier CSV est passé de 200 Mo à 20 Go, et ta machine affiche un « Killed » sans appel. Ce n'est pas toi, c'est la RAM : Pandas charge tout en mémoire, d'un seul bloc. Si les données ne rentrent pas, le script meurt. Dask est né pour ça. C'est une bibliothèque Python qui découpe tes données en morceaux, les répartit sur tes cœurs de processeur, et ne calcule que ce dont tu as besoin, au moment où tu en as besoin. Et le meilleur : son API copie celle de Pandas et de NumPy. Si tu les connais déjà, tu sais déjà l'essentiel.

Le principe tient en trois idées. La paresse d'abord : Dask ne touche pas à tes données tant que tu ne le demandes pas explicitement. Le découpage ensuite : un gros tableau devient une pile de petits morceaux, les partitions. Le parallélisme enfin : ces partitions sont traitées en même temps par plusieurs cœurs, voire plusieurs machines. Résultat, des calculs qui faisaient exploser ta RAM passent sans broncher.

Étape 1 — Installe Dask

Un simple pip suffit. Pour manipuler des DataFrame, installe l'extra « dataframe », qui embarque Pandas :

bash

pip install "dask[dataframe]"

Pour profiter du tableau de bord et voir tes cœurs travailler, prends l'installation complète :

bash

pip install "dask[complete]"

Étape 2 — Lis un fichier sans le charger

La magie commence ici. Avec Pandas, read_csv charge tout en mémoire d'un coup. Avec Dask, read_csv se contente d'inspecter la structure du fichier et de préparer un plan de calcul. Rien n'est encore lu :

python

import dask.dataframe as dd

df = dd.read_csv("ventes/*.csv")
print(df)
# Dask DataFrame Structure : rien n'est chargé en mémoire

Le motif * lui permet d'avaler un dossier entier de CSV en une seule commande. df est une promesse, un graphe de tâches qui attend son heure.

Étape 3 — La même API que Pandas

Pour tester chez toi sans télécharger 20 Go, fabrique un gros tableau et convertis-le en Dask :

python

import numpy as np
import pandas as pd
import dask.dataframe as dd

n = 5_000_000
pdf = pd.DataFrame({
    "ville": np.random.choice(["Paris", "Lyon", "Marseille", "Nantes", "Lille"], n),
    "categorie": np.random.choice(["livres", "musique", "jeux", "high-tech"], n),
    "montant": np.random.randint(1, 500, n),
})

ddf = dd.from_pandas(pdf, npartitions=4)
# npartitions = nombre de morceaux traités en parallèle

À partir de là, tout ressemble à Pandas. Filtres, groupby, jointures : la syntaxe est identique. La seule différence, c'est que rien ne s'exécute encore.

Étape 4 — Calcule, puis demande le résultat

Enchaîne tes opérations comme d'habitude, puis termine par .compute() pour lancer le calcul :

python

total = ddf.groupby("categorie")["montant"].sum()
# Toujours rien : total est un plan de calcul paresseux
print(total.compute())

compute() déclenche l'exécution, répartit le travail sur les partitions et rassemble le résultat dans un objet Pandas classique. C'est le seul moment où tes données sont réellement traitées.

Étape 5 — Des tableaux géants avec dask.array

Côté calcul numérique, dask.array remplace NumPy pour les tableaux trop grands pour tenir en RAM. On découpe en blocs grâce à chunks :

python

import dask.array as da

x = da.random.random((20000, 20000), chunks=(2000, 2000))
moyenne = x.mean()
print(moyenne.compute())

Un tableau de 20 000 par 20 000, c'est 400 millions de valeurs : à peine tenable en RAM s'il était concret. Dask le garde sous forme de blocs de 2000 par 2000, et ne matérialise que la moyenne finale.

Étape 6 — Parallélise tes propres fonctions

Dask ne se limite pas aux données : il parallélise n'importe quelle fonction Python avec dask.delayed :

python

from dask import delayed
import time

@delayed
def carre(x):
    time.sleep(1)   # simule un calcul lent
    return x * x

resultats = [carre(i) for i in range(8)]
total = delayed(sum)(resultats)

print(total.compute())  # ~1 s au lieu de 8 s

Les huit appels s'exécutent en parallèle : ton goulot d'étranglement disparaît. Ajoute total.visualize() pour afficher le graphe des tâches et comprendre ce que Dask prépare.

Étape 7 — Le tableau de bord pour voir tes cœurs bosser

Pour observer la répartition du travail en temps réel, lance un client distribué :

python

from dask.distributed import Client

client = Client()  # ouvre le tableau de bord sur http://localhost:8787

Le tableau de bord affiche les tâches en cours, la mémoire consommée et la charge de chaque cœur. Indispensable pour repérer la partition qui ralentit tout le monde.

Conclusion — Quand passer à Dask ?

Dask n'est pas un remplaçant de Pandas, c'est une extension. Tant que tes données tiennent en RAM, garde Pandas : il est plus simple et plus rapide sur les petits volumes. Mais dès que ton script crie « Killed », que tes CSV se comptent en dizaines de giga-octets, ou que tu veux utiliser tous tes cœurs, remplace pd par dd, ajoute un .compute() à la fin, et regarde. C'est le pont le plus court entre ton laptop et l'échelle d'un datacenter, sans réécrire ton code.