L'ultimo cheat sheet di R data.table

Velocità. Sintassi concisa. Compatibilità con le versioni precedenti.

Ma soprattutto velocità.

Queste sono alcune delle caratteristiche che rendono il data.table di R convincente per i suoi fan.

E anche se sei un utente tidyverse confermato (come me), data.table può essere un'utile aggiunta al tuo toolkit R, specialmente quando lavori con set di dati di grandi dimensioni, in un'app Shiny o in una funzione di pacchetto. 

Questo ultimo cheat sheet di R data.table è diverso da molti altri perché è interattivo. Puoi cercare una frase specifica come aggiungi colonna o un tipo di gruppo di attività come Sottoinsieme o Risagoma . Inoltre, poiché questo cheat sheet include un codice di "traduzione" ordinato, puoi anche cercare un verbo dplyr preferito come mutate o rowwise .

Gli utenti registrati possono scaricare una versione estesa di questo tavolo interattivo da utilizzare sui propri sistemi! La registrazione è gratuita. 

Cerca data.table e attività e codice tidyverse

Compito genere data.table Code Codice Tidyverse
Leggi in file CSV Importare mydt <- fread ("myfile.csv") myt <- read_csv ("myfile.csv") #OR myt <- vroom :: vroom ("myfile.csv")
Importa il primo numero x di righe di un file CSV Importare mydt_x <- fread ("myfile.csv", nrows = x) myt_x <- read_csv ("myfile.csv", n_max = x)
Importa solo le righe da un file CSV che corrispondono a un determinato modello Importare mydt_pattern <- fread ("grep 'mypattern' myfile.csv") myt_pattern <- vroom :: vroom (pipe ("grep 'mypattern' myfile.csv"))
Importa un file compresso .gz Importare mydt <- fread ("myfile.gz") myt <- vroom :: vroom ("myfile.gz")
Importa un file compresso .zip importare mydt <- fread (cmd = 'unzip -cq myfile.zip') myt <- read_csv ("myfile.zip")
Crea una tabella dati da un data frame esistente (tibble per tidyverse) Importare mydt <- as.data.table (mydf) #OR

setDT (mydf)

myt <- as_tibble (mydf)
Modifica data.table in posizione senza crearne una copia Disputa qualsiasi funzione che inizia con set come setkey (mydt, mycol) o utilizzando l'operatore: = tra parentesi non applicabile
Ordina le righe in base a più valori di colonna Disputa mydt2 <- mydt [order (colA, -colB)] #OR

setorder (mydt, colA, -colB)

myt <- arrangia (myt, colA, -colB)
Rinomina colonne Disputa setnames (mydt, old = c ('colA', 'colB'), new = c ('NewColA', 'NewColB')) myt <- rinomina (myt, NewColA = colA, NewColB = colB)
Riordinare le colonne: sposta alcune colonne in primo piano (la più a sinistra) Disputa setcolorder (mydt, c ("colB", "colC")) # colB ora in posizione 1 e colC in posizione 2 myt <- relocate (myt, colB, colC)
Filtra righe per numero riga n Sottoinsieme mydt2 <- mydt [n] myt2 <- slice (myt, n)
Filtra per l'ultima riga Sottoinsieme mydt2 <- mydt [.N] myt2 <- slice (myt, n ())
Filtra le righe per condizione Sottoinsieme # In alcuni casi setkey (mydt, colA, colB) velocizzerà le prestazioni # per i test logici su colA e colB; lo stesso con altre colonne

mydt2 <- mydt [espressione logica]

myt2 <- filter (myt, espressione logica)
Filtra le righe in cui colA è uguale a stringa1 o stringa2 Sottoinsieme mydt2 <- mydt [colA% chin% c ("string1", "string2")] myt2 <- filter (myt, colA% in% c ("string1", "string2"))
Filtra le righe in cui colA corrisponde a un'espressione regolare Sottoinsieme mydt2 <- mydt [colA% like% "mypattern"] myt2 <- filter (myt, stringr :: str_detect (colA, "mypattern"))
Filtra le righe in cui i valori di colA sono compresi tra 2 numeri Sottoinsieme mydt2 <- mydt [colA% tra% c (n1, n2)] myt2 <- filtro (myt, between (colA, n1, n2))
Filtra per prime n righe per gruppo Sottoinsieme mydt2 <- mydt [, .SD [1: n], by = groupcol] myt2% group_by (groupcol)%>% slice (1: n)
Filtra le righe per il valore massimo per gruppo Sottoinsieme mydt2 <- mydt [, .SD [which.max (valcol)], by = groupcol] myt2% group_by (groupcol)%>% filtro (valcol == max (valcol))
Seleziona la colonna e restituisci i risultati come vettore Sottoinsieme myvec <- mydt [, colname] myvec <- pull (myt, colname)
Seleziona più colonne per creare un nuovo data.table (data frame o tibble per tidyverse) Sottoinsieme mydt2 <- mydt [, list (colA, colB)] #OR

mydt2 <- mydt [,. (colA, colB)] #OR

mydt2 <- mydt [, c ("colA", "colB")]

myt2 <- seleziona (myt, colA, colB)
Seleziona più colonne utilizzando una variabile contenente i nomi delle colonne Sottoinsieme my_col_names <- c ("colA", "colB")

mydt2 <- mydt [, ..my_col_names] #OR

mydt2 <- mydt [, my_col_names, with = FALSE]

my_col_names <- c ("colA", "colB")

myt2 <- seleziona (myt, all_of (my_col_names))

Seleziona più colonne e rinominane alcune Sottoinsieme mydt2 <- mydt [,. (newname1 = col1, newname2 = col2, col3)] myt2 <- seleziona (myt, newname1 = col1, newname2 = col2, col3)
Escludi più colonne Sottoinsieme mydt2 <- mydt [, -c ("colA", "colB")] #OR

mydt2 <- mydt [,! c ("colA", "colB")] #OR

my_col_names <- c ("colA", "colB")

mydt2 <- mydt [,! .. my_col_names]

myt2 <- seleziona (myt, -c (colA, colB)) #OR

my_col_names <- c ("colA", "colB")

myt2 <- select (myt, - {{my_col_names}})

Rimuovi le righe duplicate in base ai valori in più colonne Sottoinsieme mydt2 <- unico (mydt, by = c ("colA", "colB")) myt2 <- distinto (myt, colA, colB, .keep_all = TRUE)
Contare righe uniche in base a più colonne Riassumere uniqueN (mydt, by = c ("colA", "colB")) nrow (distinto (myt, colA, colB))
Eseguire calcoli di riepilogo sui dati Riassumere mydt2 <- mydt [, myfun (colA ...)] myt2% riepiloga (ColName = myfun (colA ...))
Esegui calcoli di riepilogo sui dati di un gruppo Riassumere mydt2 <- mydt [, myfun (colA ...), by = groupcol] myt2%

group_by (groupcol)%>%

riassumere(

NewCol = myfun (colA ...)

)

Esegui calcoli di riepilogo sui dati di un gruppo e assegna un nome alla nuova colonna Riassumere mydt2 <- mydt [,. (MyNewCol = myfun (colA ...)), by = groupcol] myt2%

group_by (groupcol)%>%

riassumere(

NewCol = myfun (colA ...)

)

Eseguire calcoli di riepilogo sui dati di più gruppi Riassumere mydt2 <- mydt [, myfun (colA ...), by =. (groupcol1, groupcol2)] myt2%

group_by (groupcol1, groupcol2)%>%

riassumere(

NewCol = myfun (colA ...)

)

Eseguire il calcolo di riepilogo sui dati filtrati da più gruppi Riassumere mydt2 <- mydt [espressione di filtro, myfun (colA), by =. (groupcol1, groupcol2)] myt2%

filtro (espressione filtro)%>%

group_by (groupcol1, groupcol2)%>%

riassumere(

NewCol = myfun (colA), .groups = "keep"

)

Contare il numero di righe per gruppi Riassumere mydt2 <- mydt [,. N, by = groupcol] #per un gruppo #OR

mydt2 <- mydt [, .N, by =. (groupcol1, groupcol2)]

myt2 <- count (myt, groupcol) #per un gruppo #OR

myt2 <- count (myt, groupcol1, groupcol2)

Riepiloga più colonne e restituisci i risultati in più colonne Riassumere mydt2 <- mydt [, lapply (.SD, myfun),

.SDcols = c ("colA", "colB")]

myt2%

riassumere(

attraverso (c (colA, colB), myfun)

)

Riepiloga più colonne per gruppo e restituisci i risultati in più colonne Riassumere mydt2 <- mydt [, lapply (.SD, myfun),

.SDcols = c ("colA", "colB"), di = groupcol]

myt2%

group_by (groupcol)%>%

riepilogare (across (c (colA, colB), myfun))

Aggiungi una colonna Calcolare mydt [, MyNewCol: = myfun (colA)] myt%

mutare (

MyNewCol = myfun (colA)

)

Aggiungi più colonne contemporaneamente Calcolare # usa qualsiasi funzione o espressione

mydt [, `: =` (NewCol1 = myfun (colA), NewCol2 = colB + colC)] #OR

mydt [, c ("NewCol1", "newCol2"): = list (myfun (colA), colB + colC)]

myt%

mutare (

MyNewCol1 = myfun (colA),

MyNewCol2 = colB + colC

)

Aggiungi colonna utilizzando i valori correnti e precedenti di un'altra colonna, ad esempio la ricerca della differenza tra il valore in una data e la data precedente Calcolare mydt [, Diff: = colA - shift (colA)] myt <- mutate (myt, Diff = colA - lag (colA))
Aggiungi colonna che fa riferimento al valore precedente di una colonna da parte di un gruppo Calcolare mydt2 <- mydt [, Diff: = colA - shift (colA), by = groupcol] myt2% group_by (groupcol)%>% mutate (Diff = colA - lag (colA))
Aggiungi colonna con numeri ID di riga per gruppo Calcolare mydt [, myid: = 1: .N, by = groupcol] myt% group_by (groupcol)%>% mutate (myid = row_number ())
Aggiungi colonna in base a diverse condizioni senza utilizzare più istruzioni if ​​else (come CASE di SQL) Calcolare # Richiede data.table versione 1.13 o successiva

# Mi piace ogni condizione su una nuova riga, ma non è richiesta

mydt2 <- mydt [, NewCol: = fcase (

condizione1, "Valore1",

condizione2, "Valore2",

condizione3, "Valore3",

default = "Altro" # valore per tutto il resto

)]

myt2%

mutare (

NewCol = case_when (

condizione1 ~ "Valore1",

condizione2 ~ "Valore2",

condizione3 ~ "Valore3",

TRUE ~ "Altro"

)

)

Aggiungi colonna operando per riga Calcolare mydt [, newcol: = myfun (colB, colC, colD), by = 1: nrow (mydt)]

# o se colA ha tutti i valori univoci

mydt [, newcol: = myfun (colB, colC, colD), by = colA]

myt%

rowwise ()%>%

mutare (

newcol = myfun (colB, colC, colD)

)

# o

myt%

rowwise ()%>%

mutare (

#use dplyr seleziona la sintassi:

newcol = myfun (c_across (colB: colD))

)

Unisci due set di dati per più di una colonna; tieni tutto in set1 ma corrisponde solo a set2 Aderire mydt <- dt2 [dt1, on = c ("dt2col" = "dt1col")] #OR

mydt <- merge (dt1, dt2, by.x = "dt1col", by.y = "dt2col", all.x = TRUE) #OR

setkey (dt1, "dt1col") setkey (dt2, "dt2col") mydt <- dt2 [dt1]

myt <- left_join (df1, df2, by = c ("df1col" = "df2col"))
Unisci 2 set di dati da più di una colonna: mantieni tutto in set1 ma corrisponde solo a set2 Aderire mydt <- merge (dt1, dt2, by.x = c ("dt1colA", "dt1colB"), by.y = c ("dt2colA", "dt2colB"), all.x = TRUE, all.y = FALSE ) #O

setkey (dt1, dt1colA, dt1colB)

setkey (dt2, dt2colA, dt2colB)

mydt <- dt2 [dt1]

myt <- left_join (df1, df2, by = c ("df1colA" = "df2colA", "df1colB" = "df2colB"))
Unisci due set di dati da una colonna comune; tieni solo i fiammiferi Aderire mydt <- merge (dt1, dt2, by.x = "dtcol1", by.y = "dtcol2") myt <- inner_join (df1, df2, by = c ("df1col" = "df2col"))
Unisci due set di dati da una colonna comune e mantieni tutti i dati in entrambi i set, indipendentemente dal fatto che ci siano o meno corrispondenze Aderire mydt <- merge (dt1, dt2, by.x = "dtcol1", by.y = "dtcol2", all = TRUE) myt <- full_join (df1, df2, by = c ("df1col" = "df2col"))
Combina due set di dati aggiungendo righe da uno alla fine dell'altro Aderire mydt_joined <- rbindlist (list (mydt, mydt2)) myt_joined <- bind_rows (myt, myt2)
Rimodella i dati da larghi a lunghi Rimodellare mydt_long <- melt (mydt, measure.vars = c ("col1", "col2", "col3"), variable.name = "NewCategoryColName", value.name = "NewValueColName") myt_long <- pivot_longer (myt, cols = starts_with ("col"), names_to = "NewCategoryColName", values_to = "NewValueColName")
Rimodella i dati da lunghi a larghi Rimodellare mydt_wide <- dcast (mydt, id_col1 ~ col1, value.var = "ValueColName") myt_wide <- pivot_wider (myt, names_from = col1, values_from = ValueColName)
Concatena più espressioni Disputa mydt [expr1] [expr2] myt%

expr1%>%

expr2

Esporta i dati in un file CSV Esportare fwrite (miodt, "miofile.csv") write_csv (myt, "myfile.csv")
Aggiungi righe a un file CSV esistente Esportare fwrite (mydt2, "myfile.csv", append = TRUE) vroom :: vroom_write (myt2, "myfile.csv", delim = ",", append = TRUE)
Esporta i dati in un file CSV compresso Esportare fwrite (mydt, "myfile.csv.gz", compress = "gzip") vroom :: vroom_write (myt, "myfile2.csv.gz")

C'è molto altro da imparare su data.table! Per alcune nozioni di base su data.table, guarda il mio video introduttivo di cinque minuti:

Infine, il sito web data.table contiene molte più informazioni e suggerimenti, come l'utilizzo setkey()e altri suggerimenti per l'indicizzazione.