Velocidad. Sintaxis concisa. Compatibilidad al revés.
Pero sobre todo velocidad.
Esas son algunas de las características que hacen que data.table sea atractivo para sus fanáticos.
E incluso si eres un usuario tidyverse confirmado (como yo), data.table puede ser una adición útil a tu kit de herramientas de R, especialmente cuando trabajas con grandes conjuntos de datos, en una aplicación Shiny o en una función de paquete.
Esta hoja de trucos definitiva de R data.table es diferente de muchas otras porque es interactiva. Puede buscar una frase específica como agregar columna o por un tipo de grupo de tareas como Subconjunto o Remodelar . Además, debido a esta hoja de trucos incluye tidyverse código de “traducción”, también puede buscar un dplyr favorita verbo como mutan o por filas .
Los usuarios registrados pueden descargar una versión ampliada de esta tabla interactiva para usarla en sus propios sistemas. La inscripción es gratuita.
Buscar tareas y código data.table y tidyverse
| Tarea | Tipo | código data.table | Código de Tidyverse |
|---|---|---|---|
| Leer en archivo CSV | Importar | mydt <- fread ("myfile.csv") | myt <- read_csv ("myfile.csv") #O myt <- vroom :: vroom ("myfile.csv") |
| Importar el primer número x de filas de un archivo CSV | Importar | mydt_x <- fread ("myfile.csv", nrows = x) | myt_x <- read_csv ("myfile.csv", n_max = x) |
| Importe solo aquellas filas de un archivo CSV que coincidan con un patrón determinado | Importar | mydt_pattern <- fread ("grep 'mypattern' myfile.csv") | myt_pattern <- vroom :: vroom (pipe ("grep 'mypattern' myfile.csv")) |
| Importar un archivo comprimido .gz | Importar | mydt <- fread ("myfile.gz") | myt <- vroom :: vroom ("myfile.gz") |
| Importar un archivo comprimido .zip | importar | mydt <- fread (cmd = 'descomprimir -cq myfile.zip') | myt <- read_csv ("myfile.zip") |
| Crear una tabla de datos a partir de un marco de datos existente (tibble para tidyverse) | Importar | mydt <- as.data.table (mydf) #O setDT (mydf) |
myt <- as_tibble (mydf) |
| Altere data.table en su lugar sin hacer una copia | Reñir a | cualquier función que comience con set como setkey (mydt, mycol) o usando el operador: = entre corchetes | no aplica |
| Ordenar filas en función de varios valores de columna | Reñir a | mydt2 <- mydt [pedido (colA, -colB)] #O setorder (mydt, colA, -colB) |
myt <- organizar (myt, colA, -colB) |
| Cambiar el nombre de las columnas | Reñir a | setnames (mydt, old = c ('colA', 'colB'), new = c ('NewColA', 'NewColB')) | myt <- renombrar (myt, NewColA = colA, NewColB = colB) |
| Reordenación de columnas: mueva algunas columnas a la posición frontal (más a la izquierda) | Reñir a | setcolorder (mydt, c ("colB", "colC")) # colB ahora en la posición 1 y colC en la posición 2 | myt <- reubicar (myt, colB, colC) |
| Filtrar filas para el número de fila n | Subconjunto | mydt2 <- mydt [n] | myt2 <- rebanada (myt, n) |
| Filtrar por la última fila | Subconjunto | mydt2 <- mydt [.N] | myt2 <- rebanada (myt, n ()) |
| Filtrar filas por condición | Subconjunto | # En algunos casos, setkey (mydt, colA, colB) acelerará el rendimiento # para pruebas lógicas en colA y colB; lo mismo con otras columnas mydt2 <- mydt [expresión lógica] |
myt2 <- filtro (myt, expresión lógica) |
| Filtrar filas donde colA es igual a string1 o string2 | Subconjunto | mydt2 <- mydt [colA% chin% c ("cadena1", "cadena2")] | myt2 <- filtro (myt, colA% en% c ("cadena1", "cadena2")) |
| Filtrar filas donde colA coincide con una expresión regular | Subconjunto | mydt2 <- mydt [colA% like% "mypattern"] | myt2 <- filter (myt, stringr :: str_detect (colA, "mypattern")) |
| Filtrar filas donde los valores de colA están entre 2 números | Subconjunto | mydt2 <- mydt [colA% entre% c (n1, n2)] | myt2 <- filtro (myt, entre (colA, n1, n2)) |
| Filtrar las primeras n filas por grupo | Subconjunto | mydt2 <- mydt [, .SD [1: n], por = groupcol] | myt2% group_by (groupcol)%>% slice (1: n) |
| Filtrar filas para obtener el valor máximo por grupo | Subconjunto | mydt2 <- mydt [, .SD [which.max (valcol)], por = groupcol] | myt2% group_by (groupcol)%>% filter (valcol == max (valcol)) |
| Seleccione la columna y devuelva los resultados como un vector | Subconjunto | myvec <- mydt [, colname] | myvec <- pull (myt, colname) |
| Seleccione varias columnas para crear una nueva tabla de datos (marco de datos o tibble para tidyverse) | Subconjunto | mydt2 <- mydt [, lista (colA, colB)] #O mydt2 <- mydt [,. (colA, colB)] #O mydt2 <- mydt [, c ("colA", "colB")] |
myt2 <- seleccionar (myt, colA, colB) |
| Seleccione varias columnas usando una variable que contenga los nombres de las columnas | Subconjunto | my_col_names <- c ("colA", "colB") mydt2 <- mydt [, ..my_col_names] #O mydt2 <- mydt [, my_col_names, with = FALSE] |
my_col_names <- c ("colA", "colB") myt2 <- seleccionar (myt, all_of (my_col_names)) |
| Seleccione varias columnas y cambie el nombre de algunas | Subconjunto | mydt2 <- mydt [,. (newname1 = col1, newname2 = col2, col3)] | myt2 <- seleccionar (myt, newname1 = col1, newname2 = col2, col3) |
| Excluir varias columnas | Subconjunto | mydt2 <- mydt [, -c ("colA", "colB")] #O mydt2 <- mydt [,! c ("colA", "colB")] #O my_col_names <- c ("colA", "colB") mydt2 <- mydt [,! .. my_col_names] |
myt2 <- seleccionar (myt, -c (colA, colB)) #OR my_col_names <- c ("colA", "colB") myt2 <- select (myt, - {{my_col_names}}) |
| Eliminar filas duplicadas según los valores de varias columnas | Subconjunto | mydt2 <- único (mydt, by = c ("colA", "colB")) | myt2 <- distinto (myt, colA, colB, .keep_all = TRUE) |
| Cuente filas únicas basadas en múltiples columnas | Resumir | uniqueN (mydt, by = c ("colA", "colB")) | nrow (distinto (myt, colA, colB)) |
| Ejecutar cálculos resumidos sobre datos | Resumir | mydt2 <- mydt [, myfun (colA ...)] | myt2% resume (ColName = myfun (colA ...)) |
| Ejecute cálculos resumidos en datos por un grupo | Resumir | mydt2 <- mydt [, myfun (colA ...), por = groupcol] | myt2% group_by (groupcol)%>% resumir( NewCol = myfun (colA ...) ) |
| Ejecute cálculos resumidos en datos por un grupo y nombre una nueva columna | Resumir | mydt2 <- mydt [,. (MyNewCol = myfun (colA ...)), por = groupcol] | myt2% group_by (groupcol)%>% resumir( NewCol = myfun (colA ...) ) |
| Ejecutar cálculos resumidos en datos de varios grupos | Resumir | mydt2 <- mydt [, myfun (colA ...), por =. (groupcol1, groupcol2)] | myt2% group_by (groupcol1, groupcol2)%>% resumir( NewCol = myfun (colA ...) ) |
| Ejecutar un cálculo de resumen en datos filtrados por varios grupos | Resumir | mydt2 <- mydt [expresión de filtro, myfun (colA), por =. (groupcol1, groupcol2)] | myt2% filter (expresión de filtro)%>% group_by (groupcol1, groupcol2)%>% resumir( NewCol = myfun (colA), .groups = "mantener" ) |
| Contar el número de filas por grupos | Resumir | mydt2 <- mydt [,. N, by = groupcol] # para un grupo #O mydt2 <- mydt [, .N, por =. (groupcol1, groupcol2)] |
myt2 <- count (myt, groupcol) # para un grupo #O myt2 <- recuento (myt, groupcol1, groupcol2) |
| Resuma varias columnas y devuelva resultados en varias columnas | Resumir | mydt2 <- mydt [, lapply (.SD, myfun), .SDcols = c ("colA", "colB")] |
myt2% resumir( a través de (c (colA, colB), myfun) ) |
| Resumir varias columnas por grupo y devolver resultados en varias columnas | Resumir | mydt2 <- mydt [, lapply (.SD, myfun), .SDcols = c ("colA", "colB"), por = groupcol] |
myt2% group_by (groupcol)%>% resumir (a través de (c (colA, colB), myfun)) |
| Agregar una columna | Calcular | mydt [, MyNewCol: = myfun (colA)] | myt% mudar( MyNewCol = myfun (colA) ) |
| Agregar varias columnas a la vez | Calcular | # usa cualquier función o expresión mydt [, `: =` (NewCol1 = myfun (colA), NewCol2 = colB + colC)] #O mydt [, c ("NewCol1", "newCol2"): = lista (myfun (colA), colB + colC)] |
myt% mudar( MyNewCol1 = myfun (colA), MyNewCol2 = colB + colC ) |
| Agregue una columna usando los valores actuales y anteriores de otra columna, como encontrar la diferencia entre el valor en una fecha y la fecha anterior | Calcular | mydt [, Diff: = colA - shift (colA)] | myt <- mutate (myt, Diff = colA - lag (colA)) |
| Agregar columna que hace referencia al valor anterior de una columna por grupo | Calcular | mydt2 <- mydt [, Diff: = colA - shift (colA), by = groupcol] | myt2% group_by (groupcol)%>% mutate (Diff = colA - lag (colA)) |
| Agregar columna con números de identificación de fila por grupo | Calcular | mydt [, myid: = 1: .N, by = groupcol] | myt% group_by (groupcol)%>% mutate (myid = número_fila ()) |
| Agregue una columna basada en varias condiciones sin usar múltiples declaraciones if else (como CASE de SQL) | Calcular | # Necesita data.table versión 1.13 o posterior # Me gusta cada condición en una nueva línea pero eso no es obligatorio mydt2 <- mydt [, NewCol: = fcase ( condición1, "Valor1", condición2, "Valor2", condición3, "Valor3", valor predeterminado = "Otro" # para todo lo demás )] |
myt2% mudar( NewCol = case_when ( condición1 ~ "Valor1", condición2 ~ "Valor2", condición3 ~ "Valor3", VERDADERO ~ "Otro" ) ) |
| Agregar columna mediante operación por fila | Calcular | mydt [, newcol: = myfun (colB, colC, colD), por = 1: nrow (mydt)] # o si colA tiene todos los valores únicos mydt [, newcol: = myfun (colB, colC, colD), por = colA] |
myt% por filas ()%>% mudar( newcol = myfun (colB, colC, colD) ) # o myt% por filas ()%>% mudar( #utilice la sintaxis de selección de dplyr: newcol = myfun (c_across (colB: colD)) ) |
| Une dos conjuntos de datos por más de una columna; mantener todo en set1 pero solo coincidencias en set2 | Unirse | mydt <- dt2 [dt1, on = c ("dt2col" = "dt1col")] #O mydt <- merge (dt1, dt2, by.x = "dt1col", by.y = "dt2col", all.x = TRUE) #O setkey (dt1, "dt1col") setkey (dt2, "dt2col") mydt <- dt2 [dt1] |
myt <- left_join (df1, df2, by = c ("df1col" = "df2col")) |
| Unir 2 conjuntos de datos por más de una columna: mantener todos en el conjunto 1 pero solo las coincidencias en el conjunto 2 | Unirse | 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")) |
| Une dos conjuntos de datos por una columna común; solo guarda fósforos | Unirse | mydt <- fusionar (dt1, dt2, by.x = "dtcol1", by.y = "dtcol2") | myt <- inner_join (df1, df2, by = c ("df1col" = "df2col")) |
| Unir dos conjuntos de datos por una columna común y mantener todos los datos en ambos conjuntos, haya o no coincidencias | Unirse | mydt <- fusionar (dt1, dt2, by.x = "dtcol1", by.y = "dtcol2", all = TRUE) | myt <- full_join (df1, df2, by = c ("df1col" = "df2col")) |
| Combine dos conjuntos de datos agregando filas de una a la parte inferior de otra | Unirse | mydt_joined <- rbindlist (lista (mydt, mydt2)) | myt_joined <- bind_rows (myt, myt2) |
| Cambiar la forma de los datos de ancho a largo | Remodelar | 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") |
| Cambiar la forma de los datos de largo a ancho | Remodelar | mydt_wide <- dcast (mydt, id_col1 ~ col1, value.var = "ValueColName") | myt_wide <- pivot_wider (myt, names_from = col1, values_from = ValueColName) |
| Encadena múltiples expresiones | Reñir a | mydt [expr1] [expr2] | myt% expr1%>% expr2 |
| Exportar datos a un archivo CSV | Exportar | fwrite (mydt, "myfile.csv") | write_csv (myt, "myfile.csv") |
| Agregar filas a un archivo CSV existente | Exportar | fwrite (mydt2, "myfile.csv", append = TRUE) | vroom :: vroom_write (myt2, "myfile.csv", delim = ",", append = TRUE) |
| Exportar datos a un archivo CSV comprimido | Exportar | fwrite (mydt, "myfile.csv.gz", compress = "gzip") | vroom :: vroom_write (myt, "myfile2.csv.gz") |
¡Hay mucho más que aprender sobre data.table! Para conocer algunos conceptos básicos de data.table, consulte mi video introductorio de cinco minutos:
Finalmente, el sitio web data.table tiene mucha más información y consejos, como el uso setkey()y otros consejos de indexación.
