dplyr en R : filter, select, mutate, summarize — une intro pratique

Ce qu'est dplyr

dplyr est le package R le plus populaire pour la manipulation de données - une « grammaire des données » construite à partir d'une poignée de verbes. Chaque verbe est une fonction qui prend un data frame, fait exactement un travail (garder certaines lignes, ajouter une colonne, calculer un résumé par groupe), et renvoie un nouveau data frame. Comme chaque verbe a la même forme - un data frame entre, un data frame sort - ils s'emboîtent avec le pipe en pipelines qui se lisent de haut en bas comme une recette. dplyr est le cœur du tidyverse, une famille de packages (tidyr, ggplot2, readr) qui partagent ce design.

Tout ce que fait dplyr, R de base le fait aussi. Voici une petite analyse en pur R de base - filtrer le jeu de données intégré mtcars sur les voitures à 6 cylindres, calculer une nouvelle colonne, et en faire la moyenne par nombre de vitesses. Celle-ci s'exécute :

cars4 <- mtcars[mtcars$cyl == 4, ]
cars4$kml <- cars4$mpg * 0.425   # miles/gallon -> km/liter

result <- aggregate(kml ~ gear, data = cars4, FUN = mean)
result$kml <- round(result$kml, 1)
print(result)

Ça marche, et c'est du bon R. Mais remarque comme l'histoire est étalée entre indexation par crochets, une affectation avec $, et une formule. La version dplyr de la même analyse :

library(dplyr)

mtcars |>
    filter(cyl == 4) |>
    mutate(kml = mpg * 0.425) |>
    group_by(gear) |>
    summarize(avg_kml = round(mean(kml), 1))

Quatre verbes, dans l'ordre où tu les expliquerais à voix haute. Cette lisibilité, c'est tout l'argument de vente, et sur un pipeline de vingt étapes elle est décisive.

Les extraits dplyr de cette page sont statiques parce que cet éditeur n'exécute que R de base - pour les lancer, installe dplyr sur ta propre machine comme montré ci-dessous.

Installer et charger

Installation unique, puis chargement dans chaque script qui l'utilise :

install.packages("dplyr")   # once, per machine
library(dplyr)              # every script

Installer install.packages("tidyverse") à la place récupère dplyr plus ses frères. Quand dplyr se charge, il avertit qu'il masque stats::filter et stats::lag - c'est normal, pas une erreur.

Les six verbes de base

Chaque verbe prend le data frame comme premier argument et les noms de colonnes nus, sans guillemets ni préfixes df$.

filter() garde les lignes qui vérifient une condition :

mtcars |> filter(mpg > 25)
mtcars |> filter(cyl == 4, hp < 70)   # comma = AND

select() garde les colonnes par nom, plage ou helper :

mtcars |> select(mpg, cyl, hp)
mtcars |> select(mpg:hp)              # a range of adjacent columns
mtcars |> select(starts_with("d"))    # disp, drat

mutate() ajoute ou transforme des colonnes :

mtcars |> mutate(kml = mpg * 0.425, heavy = wt > 3.5)

arrange() trie les lignes - enveloppe une colonne dans desc() pour l'ordre décroissant :

mtcars |> arrange(desc(mpg))

summarize() réduit les lignes à une seule ligne de résumé, et group_by() lui fait faire cette réduction par groupe :

mtcars |>
    group_by(cyl) |>
    summarize(n = n(), avg_mpg = mean(mpg))

group_by() ne fait rien de visible tout seul - il ne fait que marquer le data frame pour que le prochain summarize() (ou mutate()) travaille groupe par groupe. Chaque verbe a sa doc complète dans ce chapitre : filtrer les lignes, ajouter des colonnes, trier, et résumés par groupe.

Enchaîner les verbes avec le pipe

Le pipe |> prend la valeur qui le précède et l'injecte comme premier argument de la fonction qui le suit - x |> f(y) signifie f(x, y). Comme chaque verbe dplyr prend et renvoie un data frame, les verbes s'enchaînent indéfiniment :

mtcars |>
    filter(hp > 100) |>
    mutate(kml = mpg * 0.425) |>
    group_by(cyl) |>
    summarize(cars = n(), avg_kml = round(mean(kml), 1)) |>
    arrange(desc(avg_kml))

Lis-le à voix haute : prends mtcars, garde les voitures de plus de 100 chevaux, ajoute une colonne km par litre, groupe par cylindres, compte et moyenne chaque groupe, trie par la moyenne. Pas de variables intermédiaires, pas d'imbrication. Le code plus ancien utilise %>% du package magrittr au lieu de |> - pour du dplyr ils sont interchangeables, et |> (intégré à R 4.1+) est couvert dans la doc sur les pipes.

count() et n() : les helpers de comptage

Compter est si courant que dplyr a des raccourcis. n() donne le nombre de lignes du groupe courant (valide uniquement dans summarize() ou mutate()), et count() condense toute la danse group_by() + summarize(n = n()) en un seul appel :

mtcars |> count(cyl)                    # rows per cyl value
mtcars |> count(cyl, gear, sort = TRUE) # two groupers, biggest first

Si tu te surprends à écrire group_by(x) |> summarize(n = n()), remplace-le par count(x).

Un mot sur les tibbles

Les verbes dplyr renvoient souvent un tibble - la variante tidyverse du data frame. C'est un data frame (tout ce qui en accepte un accepte un tibble), avec un affichage plus sympathique : seulement les 10 premières lignes, seulement les colonnes qui tiennent, avec les types affichés sous chaque nom. Deux différences à connaître : les tibbles n'utilisent jamais de noms de lignes (c'est pourquoi mtcars |> as_tibble() perd les noms de voitures - le tidyverse attend que les identifiants vivent dans une vraie colonne), et l'indexation à simple crochet renvoie toujours un tibble plutôt que de parfois retomber sur un vecteur. Ni l'un ni l'autre ne devrait te surprendre au quotidien ; ne panique juste pas quand str() dit tbl_df.

Ce que tu retiens

• dplyr est une grammaire : six verbes, chacun faisant un travail sur un data frame, enchaînés avec le pipe.
• filter() choisit les lignes, select() choisit les colonnes, mutate() ajoute des colonnes, arrange() trie, group_by() + summarize() agrège.
• x |> f(y) c'est f(x, y) - les pipelines se lisent de haut en bas dans l'ordre où les choses se passent.
• count() et n() couvrent la plupart des besoins de comptage.
• R de base sait tout faire ; dplyr gagne en lisibilité dès que les pipelines grandissent.

Prochaine étape : le filtrage et l'extraction en profondeur - les idiomes de crochets de R de base et où se situe le filter() de dplyr.