dplyr in R: filter, select, mutate e summarize, guida pratica

Cos'è dplyr

dplyr è il pacchetto R più popolare per la manipolazione dei dati: una "grammatica dei dati" costruita con una manciata di verbi. Ogni verbo è una funzione che prende un data frame, fa esattamente un lavoro (tenere alcune righe, aggiungere una colonna, calcolare un riepilogo per gruppo) e restituisce un nuovo data frame. Siccome ogni verbo ha la stessa forma, data frame in ingresso e data frame in uscita, si incastrano con la pipe in pipeline che si leggono dall'alto in basso come una ricetta. dplyr è il cuore del tidyverse, una famiglia di pacchetti (tidyr, ggplot2, readr) che condividono questo design.

Tutto ciò che fa dplyr lo fa anche R base. Ecco una piccola analisi in puro R base: filtra i dati integrati mtcars tenendo le auto a 4 cilindri, calcola una nuova colonna e ne fa la media per numero di marce. Questo si può eseguire:

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)

Funziona, ed è buon R. Ma nota come la storia sia sparsa tra indicizzazione con parentesi quadre, un assegnamento con $ e una formula. La versione dplyr della stessa analisi:

library(dplyr)

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

Quattro verbi, nell'ordine in cui li spiegheresti a voce. Quella leggibilità è tutto l'argomento di vendita, e su una pipeline di venti passaggi è decisiva.

I frammenti dplyr di questa pagina sono statici perché questo editor esegue solo R base: per eseguirli, installa dplyr sul tuo computer come mostrato qui sotto.

Installare e caricare

Installazione una tantum, poi caricalo in ogni script che lo usa:

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

Installando invece con install.packages("tidyverse") ottieni dplyr più i suoi fratelli. Quando dplyr si carica, avvisa che maschera stats::filter e stats::lag: è normale, non è un errore.

I sei verbi principali

Ogni verbo prende il data frame come primo argomento e i nomi delle colonne nudi, senza virgolette né prefissi df$.

filter() tiene le righe che soddisfano una condizione:

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

select() tiene le colonne per nome, intervallo o funzione di aiuto:

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

mutate() aggiunge o trasforma colonne:

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

arrange() ordina le righe; avvolgi una colonna in desc() per l'ordine decrescente:

mtcars |> arrange(desc(mpg))

summarize() riduce le righe a una riga di riepilogo, e group_by() gli fa fare la riduzione gruppo per gruppo:

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

group_by() da solo non fa niente di visibile: si limita a etichettare il data frame in modo che il summarize() (o mutate()) successivo lavori gruppo per gruppo. Ogni verbo ha una pagina completa in questo capitolo: filtrare le righe, aggiungere colonne, ordinare e riepiloghi per gruppo.

Concatenare i verbi con la pipe

La pipe |> prende il valore che la precede e lo passa come primo argomento della funzione che la segue: x |> f(y) significa f(x, y). Siccome ogni verbo dplyr prende e restituisce un data frame, i verbi si concatenano all'infinito:

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))

Leggilo ad alta voce: prendi mtcars, tieni le auto sopra i 100 cavalli, aggiungi una colonna di km per litro, raggruppa per cilindri, conta e fai la media di ogni gruppo, ordina per media. Niente variabili intermedie, niente annidamenti. Il codice più vecchio usa %>% del pacchetto magrittr invece di |>: per il lavoro con dplyr sono intercambiabili, e |> (integrato in R 4.1+) è trattato nella pagina sulle pipe.

count() e n(): gli aiutanti per contare

Contare è così comune che dplyr ha delle scorciatoie. n() dà il numero di righe del gruppo corrente (valido solo dentro summarize() o mutate()), e count() riduce l'intera danza group_by() + summarize(n = n()) a una sola chiamata:

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

Se ti ritrovi a scrivere group_by(x) |> summarize(n = n()), sostituiscilo con count(x).

Due parole sui tibble

I verbi dplyr spesso restituiscono un tibble, la variante del data frame secondo il tidyverse. È un data frame (tutto ciò che accetta un data frame accetta un tibble), con una stampa più amichevole: solo le prime 10 righe, solo le colonne che ci stanno, con i tipi mostrati sotto ogni nome. Due differenze da conoscere: i tibble non usano mai i nomi di riga (ecco perché mtcars |> as_tibble() perde i nomi delle auto: il tidyverse si aspetta che gli identificatori stiano in una vera colonna), e l'indicizzazione con parentesi singole restituisce sempre un tibble invece di ridursi a volte a un vettore. Nessuna delle due dovrebbe sorprenderti nel lavoro quotidiano; semplicemente non farti prendere dal panico quando str() dice tbl_df.

Cosa ti porti a casa

• dplyr è una grammatica: sei verbi, ognuno fa un lavoro su un data frame, concatenati con la pipe.
• filter() sceglie le righe, select() sceglie le colonne, mutate() aggiunge colonne, arrange() ordina, group_by() + summarize() aggrega.
• x |> f(y) è f(x, y): le pipeline si leggono dall'alto in basso nell'ordine in cui le cose succedono.
• count() e n() coprono la maggior parte delle esigenze di conteggio.
• R base può fare tutto questo; dplyr vince sulla leggibilità quando le pipeline crescono.

Prossimo passo: filtrare e selezionare in profondità, con gli idiomi a parentesi quadre di R base e il posto di filter() di dplyr.