Trabajando con data.frames/tibble en R con dplyr

Trabajando con data.frames/tibble en R con dplyr

Del data.frame al tibble

Hace unos años atrás compartí un breve post sobre utilización de funciones básicas de R para trabajar con matrice. En esta ocasión, voy a presentar algunas funciones muy útiles para trabajar con data.frames/tibbles en R utilizando el paquete dplyr.

Tenga en mente que, si bien, en apariencia una matriz es muy parecida a un data.frame, hay diferencias importantes, entre la más notorias es que la matriz sólo puede alojar datos de un sólo tipo: o sólo números o sólo texto, cuando se combinan ambos, predomina el texto y toda la información contenida en la matriz será transformada a texto. En cambio, los data.frames son estructuras más flexibles, y pueden alojar distintos tipos de datos preservando su clase, es decir, podemos tener en una columna valor numérico y en otra valores textuales y cada columna preserva su clase, no hay coerción a imponer una sola clase predominante a todo el data.frame como ocurre con las matrices.

Pese a la ventaja que presentan los data.frames para almacenamiento de datos y para la labor de análisis de datos, ya que en la realidad se cuenta con una variedad y mezcla de datos de diferentes tipos (numéricos enteros, numéricos reales, texto, categóricos), también tiene una desventaja desde el punto de vista estético, para ello existe una oportuna solución que frece el tipo tibble, que presenta una mejor estética para visualizar los datos, ya que sólo muestra las primeras 10 observaciones, además, informa sobre el tipo de datos que contiene cada variable y da información sobre la dimensión de la tabla de datos. Más allá de la estética, esta estructura permite una mejor interacción con las funciones del paquete dplyr que es protagonista de este post.

¿Qué es dplyr?

De su página oficial https://dplyr.tidyverse.org/ podemos darnos cuenta qué es y para qué sirve este paquete de R:

dplyr is a grammar of data manipulation, providing a consistent set of verbs that help you solve the most common data manipulation challenges

Es decir, que este paquete ofrece herramientas que nos ayudan a lidiar con problemas de manipulación de datos. Las principales funciones con las que cuenta son:

  • mutate() crea y agrega una nueva variable a las ya existente que puede o no ser una función de las ya existentes.
  • select() selecciona una varible por su nombre o por su posición
  • filter() como su nombre lo indica, sirve para filtrar casos según las condiciones que le proporcionemos
  • summarise para aplicar transformaciones estadísticas que nos permitan resumir los datos
  • group_by() para resúmenes y aplicación de funciones a subconjunto de casos agrupados por categorías
  • arrange() para ordenar los datos de forma ascendente/descendente
  • relocate() para cambiar de posición las columnas/variables
  • rename() para cambiar el nombre a las columnas/variables
  • across() para aplicar funciones a un conjunto de columnas/variables

Para ilustrar la versatilidad y facilidad de uso de estas funciones, usaremos la base de datos mtcars que, según su descripción, es un conjunto de datos de la edición de 1974 de la revista Motor Trend US y se compone de 11 variables sobre aspecto de diseño y desempeño de 32 automóviles de los años 1973 y 1974. Ver más información al ejecutar ?mtcars en su consola de R.

Antes de empezar, deberemos instalar y cargar dplyr y tibble:

install.packages("dplyr")
install.packages("tibble")
library(dplyr)
library(tibble)

Para llevar a cabo la exposión de las funciones, me basaré en el uso del operador %>% que, combinado, con el ecositema de tidyverse permiten una fácil lectura y mejor comprensión de los códigos, además de que, visualmente son más ordenados y atractivos.

Empecemos cargando los datos de mtcars y viendo cómo se estructura este conjunto de datos

head(mtcars)
##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

Note que si no le pido, con head() que me muestre las primeras 10 filas (valor por defecto), el programa me imprimiría todo el conjunto de datos, lo cual no es agradable, porque no sabría a qué variable se refiere cada columna, porque no sería capaz de ver su encabezado. Vemos además, con el siguiente código que mtcars se trata de un data.frame:

class(mtcars)
## [1] "data.frame"

Puede observarse que hemos necesitado de head para visualizar ‘correctamente’ (al menos de forma bonita e informativa) nuestro conjunto de datos, pero no sabemos qué tipo de variable contiene cada columna. El hecho de que se vean números no, necesariamente, implica que sean números, pueden ser cadena de texto (character) o variables dummy (factor), así que para saber qué tipo de datos contiene, procedemos de la siguiente manera:

sapply(mtcars, class)
##       mpg       cyl      disp        hp      drat        wt      qsec        vs 
## "numeric" "numeric" "numeric" "numeric" "numeric" "numeric" "numeric" "numeric" 
##        am      gear      carb 
## "numeric" "numeric" "numeric"

Para resumir hasta este punto, si tenemos un data.frame casi siempre tenemos que recurrir a head()para darnos una idea de cómo luce el conjunto de datos y, si queremos inspeccionar cada columna, debemos recurrir a sapply (o cualquier otra función de la familia *apply).

Y si quiero saber la dimensión de mi data.frame, es decir, cuántos registros tiene (filas) y cuántas variables o dimensiones (columnas), se hace con dim():

dim(mtcars)  # 32 filas y 11 columnas
## [1] 32 11

Veamos la ventaja que tendría tener mtcar como un objeto clase tibble y no data.frame

mtcars2 <- mtcars %>% 
  rownames_to_column(var = "model") %>% 
  tibble()

mtcars2 
## # A tibble: 32 x 12
##    model         mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <chr>       <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4    21       6  160    110  3.9   2.62  16.5     0     1     4     4
##  2 Mazda RX4 ~  21       6  160    110  3.9   2.88  17.0     0     1     4     4
##  3 Datsun 710   22.8     4  108     93  3.85  2.32  18.6     1     1     4     1
##  4 Hornet 4 D~  21.4     6  258    110  3.08  3.22  19.4     1     0     3     1
##  5 Hornet Spo~  18.7     8  360    175  3.15  3.44  17.0     0     0     3     2
##  6 Valiant      18.1     6  225    105  2.76  3.46  20.2     1     0     3     1
##  7 Duster 360   14.3     8  360    245  3.21  3.57  15.8     0     0     3     4
##  8 Merc 240D    24.4     4  147.    62  3.69  3.19  20       1     0     4     2
##  9 Merc 230     22.8     4  141.    95  3.92  3.15  22.9     1     0     4     2
## 10 Merc 280     19.2     6  168.   123  3.92  3.44  18.3     1     0     4     4
## # ... with 22 more rows

El código anterior realiza las siguientes acciones:

  • toma los nombres de las filas y los convierte en una nueva variable/columna (rownames_to_column)
  • nombra a la nueva variable como model
  • a ese nuevo conjunto de datos se convierte de data.frame a tibble
  • se muestra el resultado

Puede observarse que ya no se requiere usar head() o sapply, ahora, por defecto, sólo se muestran las primeras 10 observaciones y debajo de cada nombre de las variables aparece la clase de cada una de ellas, por ejemplo, debajo de model aparece su clase: character, indicando que es una variable de cadena de texto, todas la demás son numéricas con doble precisión (double). También informa sobre la dimensión del conjunto de datos justo al inicio: A tibble: 32 x 12 esto indica que se trata de un objeto tibble con 32 filas y 12 columnas, una adicional, porque añadí los nombres de filas como una columna adicional.

Ahora sí, una vez vistas las diferencias entre data.frame y tibble, podemos proceder a nuestros ejemplos.

mutate

Vamos a empezar por ‘mutar’ o cambiar la variable am que indica con 0 si la transmisión es automática y con 1 si es manual, para ello usaremos la función mutate:

mtcars2 %>% 
  mutate(am2 = factor(am, levels = c(0,1), labels = c("automatic", "manual"))) %>% 
  select(am, am2)
## # A tibble: 32 x 2
##       am am2      
##    <dbl> <fct>    
##  1     1 manual   
##  2     1 manual   
##  3     1 manual   
##  4     0 automatic
##  5     0 automatic
##  6     0 automatic
##  7     0 automatic
##  8     0 automatic
##  9     0 automatic
## 10     0 automatic
## # ... with 22 more rows

Con lo anterior hemos creado una nueva variable, am2, cambiando sus valores de 0 y 1 a ‘automatic’ y ‘manual’, respectivamente. Adicionalmente, uso la función select para seleccionar sólo las variables am y am2 para comprobar que he realizado correctamente la transformación. Note, además que, la variable am2 es de tipo fctr, es decir, es una variable factor o una variable categórica (con niveles numéricos y etiquetas de texto) que son las variables adecuadas para realizar agrupaciones para los resúmenes estadísticos.

Para los devotos del ifelse, lo anterior pudo haberse realizado así:

mtcars2 %>% 
  mutate(am2 = ifelse(am==0, "automatic", "manual")) %>% 
  select(am, am2)
## # A tibble: 32 x 2
##       am am2      
##    <dbl> <chr>    
##  1     1 manual   
##  2     1 manual   
##  3     1 manual   
##  4     0 automatic
##  5     0 automatic
##  6     0 automatic
##  7     0 automatic
##  8     0 automatic
##  9     0 automatic
## 10     0 automatic
## # ... with 22 more rows

Pese a que, aparentemente, se hizo bien, note que la variable am2 en este ejemplo no es factor, sino que es una cadena de texto (character) que no son muy buenas para la agrupación, esto se puede resolver fácilmente haciendo la coerción a factor:

mtcars2 %>% 
  mutate(am2 = ifelse(am==0, "automatic", "manual") %>% as.factor) %>% 
  select(am, am2)
## # A tibble: 32 x 2
##       am am2      
##    <dbl> <fct>    
##  1     1 manual   
##  2     1 manual   
##  3     1 manual   
##  4     0 automatic
##  5     0 automatic
##  6     0 automatic
##  7     0 automatic
##  8     0 automatic
##  9     0 automatic
## 10     0 automatic
## # ... with 22 more rows

Sin embargo, esto viola el principio de Ockham. Téngase en cuenta que si la variable tiene más de dos categorías o factores, se requeriría el uso de un ifelse anidado y esto añadiría complejidad innecesaria a nuestro propósito. Eso lo veremos con la variable cyl que indica el número de cilindros: 4, 6 u 8. Vamos a crear una variable nueva, cyl2 que sea 4=‘small’, 6=‘medium’ y 8=‘big’ para indicar el tamaño del motor en función del número de cilindros.

mtcars2 %>% 
  mutate(cyl2 = factor(cyl, levels = c(4, 6, 8), labels = c("small", "medium", "big"))) %>% 
  select(cyl, cyl2)
## # A tibble: 32 x 2
##      cyl cyl2  
##    <dbl> <fct> 
##  1     6 medium
##  2     6 medium
##  3     4 small 
##  4     6 medium
##  5     8 big   
##  6     6 medium
##  7     8 big   
##  8     4 small 
##  9     4 small 
## 10     6 medium
## # ... with 22 more rows

Efectivamente, el cambio fue correctamente realizado y no tuvimos que hacer uso de los ifelse anidados.

Una cosa importante a tener en cuenta es que si no vamos asignando estos cambios a un objeto, éstos desaparecerán, así por ejemplo, si vemos nuevamente a nuestro conjunto de datos, observaremos que no existen las variables am2ni cyl2 ya que estos no fueron guardado en ningún sitio:

mtcars2
## # A tibble: 32 x 12
##    model         mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##    <chr>       <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4    21       6  160    110  3.9   2.62  16.5     0     1     4     4
##  2 Mazda RX4 ~  21       6  160    110  3.9   2.88  17.0     0     1     4     4
##  3 Datsun 710   22.8     4  108     93  3.85  2.32  18.6     1     1     4     1
##  4 Hornet 4 D~  21.4     6  258    110  3.08  3.22  19.4     1     0     3     1
##  5 Hornet Spo~  18.7     8  360    175  3.15  3.44  17.0     0     0     3     2
##  6 Valiant      18.1     6  225    105  2.76  3.46  20.2     1     0     3     1
##  7 Duster 360   14.3     8  360    245  3.21  3.57  15.8     0     0     3     4
##  8 Merc 240D    24.4     4  147.    62  3.69  3.19  20       1     0     4     2
##  9 Merc 230     22.8     4  141.    95  3.92  3.15  22.9     1     0     4     2
## 10 Merc 280     19.2     6  168.   123  3.92  3.44  18.3     1     0     4     4
## # ... with 22 more rows

Para que nuestros cambios tengan efecto y perduren debemos asignarlos a un objeto, yo voy a actualizar la misma tabla mtcars2 para que ahí se guarden los cambios. Asimismo, vea cómo podemos realizar múltiples mutaciones a nuestra tabla con mutate, repetiré la creación de las variables am2 y cyl2:

mtcars2 <- mtcars2 %>% 
  mutate(am2 = factor(am, levels = c(0,1), labels = c("automatic", "manual")),
         cyl2 = factor(cyl, levels = c(4, 6, 8), labels = c("small", "medium", "big"))
         )

mtcars2 %>% 
  select(am, am2, cyl, cyl2)
## # A tibble: 32 x 4
##       am am2         cyl cyl2  
##    <dbl> <fct>     <dbl> <fct> 
##  1     1 manual        6 medium
##  2     1 manual        6 medium
##  3     1 manual        4 small 
##  4     0 automatic     6 medium
##  5     0 automatic     8 big   
##  6     0 automatic     6 medium
##  7     0 automatic     8 big   
##  8     0 automatic     4 small 
##  9     0 automatic     4 small 
## 10     0 automatic     6 medium
## # ... with 22 more rows

Puede observar que la actualización de la tabla la realicé mediante mtcars2 <- mtcars2... y que no hace falta llamar a mutate por cada variable a ser creada, basta con una sola vez y separar las nuevas variables por coma.

Otra característica que tiene mutate que, además de crear nuevas variables, también funciona para actualizar las que ya tenemos, así nos ahorramos el paso de crear la nueva y borrar la antigua. Veamos la variable vs que indica si el diseño del motor es en forma de V (toma valor 0) o es lineal (toma valor 1), lo que haremos es asignarle las etiquetas correspondientes y actualizar vs, actualizar significa sobreescribir en la misma variable para que tome los nuevos valores.

mtcars2 <- mtcars2 %>% 
  mutate(vs = factor(vs, levels = c(0,1), labels = c("V-shaped", "straight")))

mtcars2 %>% 
  select(model, vs)
## # A tibble: 32 x 2
##    model             vs      
##    <chr>             <fct>   
##  1 Mazda RX4         V-shaped
##  2 Mazda RX4 Wag     V-shaped
##  3 Datsun 710        straight
##  4 Hornet 4 Drive    straight
##  5 Hornet Sportabout V-shaped
##  6 Valiant           straight
##  7 Duster 360        V-shaped
##  8 Merc 240D         straight
##  9 Merc 230          straight
## 10 Merc 280          straight
## # ... with 22 more rows

¿Qué pasa si quiero nombrar mi variable con espacios? Es decir, quiero crear variables que se llamen horse power 1, horse power 2 y horse power 3 y que tengan la misma información que hp, para ello debe usarse comillas (dobles o sencillas) o el acento invertido (backtick):

mtcars2 <- mtcars2 %>% 
  mutate("horse power 1" = hp,
         'horse power 2' = hp,
         `horse power 3` = hp) 

select

Como ya se adelantó en la sección anterior, select tal cual su nombre lo indica es para seleccionar columnas por nombre (usando cadena de caracteres), por posición (usando números enteros) o por coincidencia, pero además de seleccionar, sirve para omitir variables y hasta para renombarlas! Veamos cómo funciona.

Selección por nombre

Ya esto lo hemos visto anteriormente, le damos a select el nombre de la variable que queremos que seleccione y listo!

mtcars2 %>% 
  select(mpg)

mtcars2 %>% 
  select("mpg")

mtcars2 %>% 
  select('mpg')

mtcars2 %>% 
  select(`mpg`)

Estas 4 alternativas son equivalentes:

  • la primera pasa el nombre directamente
  • la segunda pasa el nombre convertido a una cadena de caracteres dentro de comillas dobles.
  • la tercera pasa el nombre convertido a una cadena de caracteres dentro de comillas simples.
  • la cuarta pasa el nombre convertido a una cadena de caracteres dentro de acento invertido. (backtick)

Si el nombre de la variable contiene espacios, entonces la primer opción no será válida, cuando el nombre contenga espacios deberá usarse comillas o el acento invertido. En la sección anterior creamos la variable horse power 1, para seleccionarla usando select deberíamos ejecutar una de las siguientes alternativas:

mtcars2 %>% 
  select("horse power 1")

mtcars2 %>% 
  select('horse power 1')

mtcars2 %>% 
  select(`horse power 1`)

Si queremos seleccionar más de una variable, basta con separarlas con coma:

mtcars2 %>% 
  select(model, hp, "horse power 1")
## # A tibble: 32 x 3
##    model                hp `horse power 1`
##    <chr>             <dbl>           <dbl>
##  1 Mazda RX4           110             110
##  2 Mazda RX4 Wag       110             110
##  3 Datsun 710           93              93
##  4 Hornet 4 Drive      110             110
##  5 Hornet Sportabout   175             175
##  6 Valiant             105             105
##  7 Duster 360          245             245
##  8 Merc 240D            62              62
##  9 Merc 230             95              95
## 10 Merc 280            123             123
## # ... with 22 more rows

También podríamos estar interesados en extraer todas las variables excepto unas cuantas que no sean de nuestro interés, esto lo haríamos de la siguiente manera:

mtcars2 %>% 
  select(!c(model, hp, "horse power 1"))

Lo anterior selecciona todo excepto de las variables model, hp y horse power 1. La clave está en concatenar los nombres en un solo vector usando c() y luego negarlo con !. Así, la instrucción !c() dentro de un select le indicará que tome todo excepto lo que se encuentra en !c(), dicho de otra manera, lo que esté dentro de !c() será omitido.

Recordemos que a partir de am y cyl creamos am2 y cyl2, adicionalmente, a partir de hp creamos horse power 1, horse power 2 y horse power 3, así que este sería un bueno momento para eliminarlas de nuestra mtcars2.

mtcars2 <- mtcars2 %>% 
  select(!c(am, cyl, "horse power 1", "horse power 2", "horse power 3"))

select incluso permite seleccionar un rango de variables a través del operador de secuencia : es decir, si queremos seleccionar las variables desde model hasta hp podríamos indicar todos los nombres así select(model, mpg, disp, hp), pero fíjese que estas variables van una detrás de otra en secuencia, así que le podríamos indicar explícitamente a R que seleccione desde model hasta hp:

mtcars2 %>% 
  select(model:hp)
## # A tibble: 32 x 4
##    model               mpg  disp    hp
##    <chr>             <dbl> <dbl> <dbl>
##  1 Mazda RX4          21    160    110
##  2 Mazda RX4 Wag      21    160    110
##  3 Datsun 710         22.8  108     93
##  4 Hornet 4 Drive     21.4  258    110
##  5 Hornet Sportabout  18.7  360    175
##  6 Valiant            18.1  225    105
##  7 Duster 360         14.3  360    245
##  8 Merc 240D          24.4  147.    62
##  9 Merc 230           22.8  141.    95
## 10 Merc 280           19.2  168.   123
## # ... with 22 more rows

Selección por posición

Otra alternativa para seleccionar variables es a partir de su posición, es decir, podría estar interesado en seleccionar las variables mpg, hp y wt que corresponden a las posiciones 2, 4 y 6, respectivamente, para seleccionarlas procedo así:

mtcars2 %>% 
  select(2,4,6)
## # A tibble: 32 x 3
##      mpg    hp    wt
##    <dbl> <dbl> <dbl>
##  1  21     110  2.62
##  2  21     110  2.88
##  3  22.8    93  2.32
##  4  21.4   110  3.22
##  5  18.7   175  3.44
##  6  18.1   105  3.46
##  7  14.3   245  3.57
##  8  24.4    62  3.19
##  9  22.8    95  3.15
## 10  19.2   123  3.44
## # ... with 22 more rows

Al igual que con los nombres, puedo concatenar las posiciones para obtener el mismo resultado:

mtcars2 %>% 
  select(c(2,4,6))

Para el caso de omitir las variables, o seleccionar todo excepto algo, debo cambiar el operador ! por el signo - (signo menos o guión). Para este caso sí es obligatoria la concatenación:

mtcars2 %>% 
  select(-c(2,4,6))
## # A tibble: 32 x 9
##    model              disp  drat  qsec vs        gear  carb am2       cyl2  
##    <chr>             <dbl> <dbl> <dbl> <fct>    <dbl> <dbl> <fct>     <fct> 
##  1 Mazda RX4          160   3.9   16.5 V-shaped     4     4 manual    medium
##  2 Mazda RX4 Wag      160   3.9   17.0 V-shaped     4     4 manual    medium
##  3 Datsun 710         108   3.85  18.6 straight     4     1 manual    small 
##  4 Hornet 4 Drive     258   3.08  19.4 straight     3     1 automatic medium
##  5 Hornet Sportabout  360   3.15  17.0 V-shaped     3     2 automatic big   
##  6 Valiant            225   2.76  20.2 straight     3     1 automatic medium
##  7 Duster 360         360   3.21  15.8 V-shaped     3     4 automatic big   
##  8 Merc 240D          147.  3.69  20   straight     4     2 automatic small 
##  9 Merc 230           141.  3.92  22.9 straight     4     2 automatic small 
## 10 Merc 280           168.  3.92  18.3 straight     4     4 automatic medium
## # ... with 22 more rows

Asimismo, al igual que con los nombres, también puedo utilizar el operador de secuencia para seleccionar variables entre una posición y otra, incluyendo ambos extremos. Así, por ejemplo, si quiero extraer las variables entre la posición 1 y 5, haría lo siguiente:

mtcars2 %>% 
  select(1:5)

Selección por coincidencia

A veces las variables vienen con prefijos o sufijos, o simplemente contienen un patrón común que las identifica como grupos de variables, sobre todo a las que provienen de encuestas, entonces se vuelve útil conocer ciertos atajos para selección de variables por estas coincidencias.

Seleccionemos variables que empiecen por un caracter, por ejemplo la letra m

mtcars2 %>% 
  select(starts_with("m"))
## # A tibble: 32 x 2
##    model               mpg
##    <chr>             <dbl>
##  1 Mazda RX4          21  
##  2 Mazda RX4 Wag      21  
##  3 Datsun 710         22.8
##  4 Hornet 4 Drive     21.4
##  5 Hornet Sportabout  18.7
##  6 Valiant            18.1
##  7 Duster 360         14.3
##  8 Merc 240D          24.4
##  9 Merc 230           22.8
## 10 Merc 280           19.2
## # ... with 22 more rows

Selección de variables que terminen en algún caracter:

mtcars2 %>% 
  select(ends_with("t"))
## # A tibble: 32 x 2
##     drat    wt
##    <dbl> <dbl>
##  1  3.9   2.62
##  2  3.9   2.88
##  3  3.85  2.32
##  4  3.08  3.22
##  5  3.15  3.44
##  6  2.76  3.46
##  7  3.21  3.57
##  8  3.69  3.19
##  9  3.92  3.15
## 10  3.92  3.44
## # ... with 22 more rows

También se puede seleccionar aquellas que contengan un patrón particular:

mtcars2 %>% 
  select(contains("2"))
## # A tibble: 32 x 2
##    am2       cyl2  
##    <fct>     <fct> 
##  1 manual    medium
##  2 manual    medium
##  3 manual    small 
##  4 automatic medium
##  5 automatic big   
##  6 automatic medium
##  7 automatic big   
##  8 automatic small 
##  9 automatic small 
## 10 automatic medium
## # ... with 22 more rows

Cambio de nombre de las variables selecionadas

Ya vimos cómo lidiar con nombres en la creación de variables y en la selección de las mismas, ahora veamos cómo, directamente con select podemos personalizar los nombres de la tabla resultante de la selección, así por ejemplo, puedo seleccionar las variables model mpg y am2, pero quisiera llamarlas, en el resultado final, Modelo, Rendimiento y Transmisión, respectivamente, pues lo haría así:

mtcars2 %>% 
  select("Modelo" = model,
         "Rendimiento" = mpg,
         "Transmisión" = am2)
## # A tibble: 32 x 3
##    Modelo            Rendimiento Transmisión
##    <chr>                   <dbl> <fct>      
##  1 Mazda RX4                21   manual     
##  2 Mazda RX4 Wag            21   manual     
##  3 Datsun 710               22.8 manual     
##  4 Hornet 4 Drive           21.4 automatic  
##  5 Hornet Sportabout        18.7 automatic  
##  6 Valiant                  18.1 automatic  
##  7 Duster 360               14.3 automatic  
##  8 Merc 240D                24.4 automatic  
##  9 Merc 230                 22.8 automatic  
## 10 Merc 280                 19.2 automatic  
## # ... with 22 more rows

Es importante señalar que estos cambios de nombres, o más bien asignación de nombres, sólo tienen efecto en la tabla resultante de la selección y no afecta a los nombre de mtcars2, para modificar los nombres de las variables de la base de datos y actualizarlos se recomienda usar la función rename().

filter

Una vez que hemos realizado los cambios deseados/requeridos a nuestra tabla, podemos proceder a inspeccionar subtablas o bloques de información agrupadas según una condición, si este es el caso, la función filter es la que nos ayudará a completar esa misión.

mtcars2 %>% 
  filter(am2=="manual")

Como ha de intuir, la sentencia anterior nos devuelve una tabla que contiene la información de todas las variables para los casos en que am2 toma el valor manual. Es importante señalar que la función filter toma una condición, la evalúa y devuelve los resultados que cumplan dicha condición, por tanto, los operadores lógicos son el mecanismo que se debe emplear. En este sentido, debe tenerse en cuenta que el operador = funciona igual que <- y ambos son operadores de asignación y no son operadores de comparación, el comparador de igualdad en R es el doble igual ==, así que la condición que se le está proporcionando a filter(am2=="manual") es que verifique los casos que cumplan con que vs sea igual a ‘manual’. Para probar casos de diferencias, es decir, no igual se usa !=.

¿Cómo hago si quiero agregar más de una condición? Esto se realiza fácilmente al separarlas por coma, dplyr entiende que si las separo por coma éstas serán combinadas mediante el operador & y devolverá sólo aquellos casos en que sea verdadero para todas las condiciones. Esto implica que si quiero obtener los vehículos cuyo motor sea en forma de V y que, además, sean de transmisión automática y que sean grandes según el número de cilindros y que el consumo, en términos de millas por galón sea mayor o igual a 15, sólo tendría que escribir:

mtcars2 %>% 
  filter(vs == "V-shaped",
         am2 == "automatic",
         cyl2 == "big",
         mpg >= 15)
## # A tibble: 7 x 12
##   model        mpg  disp    hp  drat    wt  qsec vs      gear  carb am2    cyl2 
##   <chr>      <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <dbl> <dbl> <fct>  <fct>
## 1 Hornet Sp~  18.7  360    175  3.15  3.44  17.0 V-sha~     3     2 autom~ big  
## 2 Merc 450SE  16.4  276.   180  3.07  4.07  17.4 V-sha~     3     3 autom~ big  
## 3 Merc 450SL  17.3  276.   180  3.07  3.73  17.6 V-sha~     3     3 autom~ big  
## 4 Merc 450S~  15.2  276.   180  3.07  3.78  18   V-sha~     3     3 autom~ big  
## 5 Dodge Cha~  15.5  318    150  2.76  3.52  16.9 V-sha~     3     2 autom~ big  
## 6 AMC Javel~  15.2  304    150  3.15  3.44  17.3 V-sha~     3     2 autom~ big  
## 7 Pontiac F~  19.2  400    175  3.08  3.84  17.0 V-sha~     3     2 autom~ big

Por otro lado, si en lugar de usar & (AND) quiero usar | (OR), es decir, seleccionar los casos donde vs sea V-shaped y hp sea mayor a 100 y cyl2 sea “medium” o “big”; visualizar sólo 10 casos de esas variables más el modelo del vehículo:

mtcars2 %>% 
  filter(vs == "V-shaped",
         hp > 100,
         cyl2 == "medium" | cyl2 == "big") %>% 
  select(model, vs, hp, cyl2)
## # A tibble: 17 x 4
##    model               vs          hp cyl2  
##    <chr>               <fct>    <dbl> <fct> 
##  1 Mazda RX4           V-shaped   110 medium
##  2 Mazda RX4 Wag       V-shaped   110 medium
##  3 Hornet Sportabout   V-shaped   175 big   
##  4 Duster 360          V-shaped   245 big   
##  5 Merc 450SE          V-shaped   180 big   
##  6 Merc 450SL          V-shaped   180 big   
##  7 Merc 450SLC         V-shaped   180 big   
##  8 Cadillac Fleetwood  V-shaped   205 big   
##  9 Lincoln Continental V-shaped   215 big   
## 10 Chrysler Imperial   V-shaped   230 big   
## 11 Dodge Challenger    V-shaped   150 big   
## 12 AMC Javelin         V-shaped   150 big   
## 13 Camaro Z28          V-shaped   245 big   
## 14 Pontiac Firebird    V-shaped   175 big   
## 15 Ford Pantera L      V-shaped   264 big   
## 16 Ferrari Dino        V-shaped   175 medium
## 17 Maserati Bora       V-shaped   335 big

Note que las condiciones con | (OR) van sin coma y separadas explícitamente por el operador |.

Para seleccionar los casos que estén dentro de un intervalo, por ejemplo, donde hp esté entre 110 y 175 (incluyéndolos) se puede hacer lo siguiente:

mtcars2 %>% 
  filter(hp >= 110,
         hp <= 175) 

o alternativamente

mtcars2 %>% 
  filter(hp >= 110 &  hp <= 175) 

Personalmente prefiero usar la primera de las opciones, pero la segunda está para aquellos amantes del &.

summarise

La función summarise permite aplicar transformaciones estadísticas para resumir el comportamiento de los datos. Así, si quiero obtener la media y desviación de la variable hp, usaría summarise de la siguiente manera:

mtcars2 %>% 
  summarise(mean(mpg),
            sd(mpg))
## # A tibble: 1 x 2
##   `mean(mpg)` `sd(mpg)`
##         <dbl>     <dbl>
## 1        20.1      6.03

Por defecto, summarise me nombra las variables de resultado con el nombre del llamado de la función que apliqué, lo cual no luce del todo sexy, sin embargo summarise nos da la oportunidad de corregir esto y personalizar nuestros nombres, basta con asignar el resultado a un nombre, por ejemplo mpg_media será el promedio de mpg y mpg_sd será la desviación estándar de mpg.

mtcars2 %>% 
  summarise(mpg_media = mean(mpg),
            mpg_sd = sd(mpg))
## # A tibble: 1 x 2
##   mpg_media mpg_sd
##       <dbl>  <dbl>
## 1      20.1   6.03

group_by

Claramente el resultado anterior es un resultado global, es decir, es el promedio de millas recorridas por cada galón de combustible consumido, sin embargo, tenemos distintos tipos de vehículos en función de la transmisión y en términos de la cilindrada. Podríamos, por ejemplo, estar interesados en verificar si existen indicios de diferencias en el rendimiento del combustible según la transmisión que usan los vehículos, para ello tendríamos que agrupar y realizar un summarise; podríamos hacerlo con filter + summarise

mtcars2 %>% 
  filter(am2 == "manual") %>% 
  summarise(mpg_media_manual = mean(mpg))

mtcars2 %>% 
  filter(am2 == "automatic") %>% 
  summarise(mpg_media_auto = mean(mpg))

O puedo puedo aprovechar la potencia de group_by para agrupar por tipo de transmisión y luego obtener la media de mpg:

mtcars2 %>% 
  group_by(am2) %>% 
  summarise(media_mpg = mean(mpg)) %>% 
  ungroup
## # A tibble: 2 x 2
##   am2       media_mpg
##   <fct>         <dbl>
## 1 automatic      17.1
## 2 manual         24.4

Es muy conveniente desagrupar los datos si ya no vamos a continuar haciendo operaciones sobre ese agrupamiento.

En el siguiente ejemplo, se muestra que se pueden agregar varias variables a summarise + group_by:

mtcars2 %>% 
  group_by(am2) %>% 
  summarise(media_mpg = mean(mpg),
            meida_disp = mean(disp),
            media_drat = mean(drat)) %>% 
  ungroup
## # A tibble: 2 x 4
##   am2       media_mpg meida_disp media_drat
##   <fct>         <dbl>      <dbl>      <dbl>
## 1 automatic      17.1       290.       3.29
## 2 manual         24.4       144.       4.05

Puede ser que también estemos interesados en ir a un mayor nivel de agrupación y queramos observar si existen diferencias en las millas recorridas por galón de combustible dado el tipo de transmisión y la forma del motor. En este caso tenemos una sola variable para la media, pero dos grupos.

mtcars2 %>% 
  group_by(am2, vs) %>% 
  summarise(mpg_promedio = mean(mpg))
## # A tibble: 4 x 3
## # Groups:   am2 [2]
##   am2       vs       mpg_promedio
##   <fct>     <fct>           <dbl>
## 1 automatic V-shaped         15.0
## 2 automatic straight         20.7
## 3 manual    V-shaped         19.8
## 4 manual    straight         28.4

arrange

Esta función, como su nombre lo indica, ordena la base de datos en función de una o más variables, ya sea de manera descendente o ascendente. Así, por ejemplo, si quiero ordenar toda la base de datos de forma ascendente, según mpg, haría lo siguiente:

mtcars2 %>% 
  arrange(mpg)
## # A tibble: 32 x 12
##    model       mpg  disp    hp  drat    wt  qsec vs      gear  carb am2    cyl2 
##    <chr>     <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <dbl> <dbl> <fct>  <fct>
##  1 Cadillac~  10.4  472    205  2.93  5.25  18.0 V-sha~     3     4 autom~ big  
##  2 Lincoln ~  10.4  460    215  3     5.42  17.8 V-sha~     3     4 autom~ big  
##  3 Camaro Z~  13.3  350    245  3.73  3.84  15.4 V-sha~     3     4 autom~ big  
##  4 Duster 3~  14.3  360    245  3.21  3.57  15.8 V-sha~     3     4 autom~ big  
##  5 Chrysler~  14.7  440    230  3.23  5.34  17.4 V-sha~     3     4 autom~ big  
##  6 Maserati~  15    301    335  3.54  3.57  14.6 V-sha~     5     8 manual big  
##  7 Merc 450~  15.2  276.   180  3.07  3.78  18   V-sha~     3     3 autom~ big  
##  8 AMC Jave~  15.2  304    150  3.15  3.44  17.3 V-sha~     3     2 autom~ big  
##  9 Dodge Ch~  15.5  318    150  2.76  3.52  16.9 V-sha~     3     2 autom~ big  
## 10 Ford Pan~  15.8  351    264  4.22  3.17  14.5 V-sha~     5     4 manual big  
## # ... with 22 more rows

Si, en cambio, la hubiese querido ordenar de forma descendente, bastaría con hacer lo siguiente:

mtcars2 %>% 
  arrange(desc(mpg))

mtcars2 %>% 
  arrange(-mpg)  # ambas formas son equivalentes

Y si lo que quiero es ordenar de forma descendente, primero por mpg y luego por disp, entonces procedo así:

mtcars2 %>% 
  arrange(desc(mpg), desc(disp))
## # A tibble: 32 x 12
##    model       mpg  disp    hp  drat    wt  qsec vs      gear  carb am2    cyl2 
##    <chr>     <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <dbl> <dbl> <fct>  <fct>
##  1 Toyota C~  33.9  71.1    65  4.22  1.84  19.9 strai~     4     1 manual small
##  2 Fiat 128   32.4  78.7    66  4.08  2.2   19.5 strai~     4     1 manual small
##  3 Lotus Eu~  30.4  95.1   113  3.77  1.51  16.9 strai~     5     2 manual small
##  4 Honda Ci~  30.4  75.7    52  4.93  1.62  18.5 strai~     4     2 manual small
##  5 Fiat X1-9  27.3  79      66  4.08  1.94  18.9 strai~     4     1 manual small
##  6 Porsche ~  26   120.     91  4.43  2.14  16.7 V-sha~     5     2 manual small
##  7 Merc 240D  24.4 147.     62  3.69  3.19  20   strai~     4     2 autom~ small
##  8 Merc 230   22.8 141.     95  3.92  3.15  22.9 strai~     4     2 autom~ small
##  9 Datsun 7~  22.8 108      93  3.85  2.32  18.6 strai~     4     1 manual small
## 10 Toyota C~  21.5 120.     97  3.7   2.46  20.0 strai~     3     1 autom~ small
## # ... with 22 more rows

El ordenamiento de los tibbles no se limita sólo a variables numéricas, puedo usar arrange() incluso para ordenar por model, que como ha de esperar el lector, el ordenamiento lo hace alfabéticamente:

mtcars2 %>% 
  arrange(model)
## # A tibble: 32 x 12
##    model       mpg  disp    hp  drat    wt  qsec vs      gear  carb am2    cyl2 
##    <chr>     <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <dbl> <dbl> <fct>  <fct>
##  1 AMC Jave~  15.2 304     150  3.15  3.44  17.3 V-sha~     3     2 autom~ big  
##  2 Cadillac~  10.4 472     205  2.93  5.25  18.0 V-sha~     3     4 autom~ big  
##  3 Camaro Z~  13.3 350     245  3.73  3.84  15.4 V-sha~     3     4 autom~ big  
##  4 Chrysler~  14.7 440     230  3.23  5.34  17.4 V-sha~     3     4 autom~ big  
##  5 Datsun 7~  22.8 108      93  3.85  2.32  18.6 strai~     4     1 manual small
##  6 Dodge Ch~  15.5 318     150  2.76  3.52  16.9 V-sha~     3     2 autom~ big  
##  7 Duster 3~  14.3 360     245  3.21  3.57  15.8 V-sha~     3     4 autom~ big  
##  8 Ferrari ~  19.7 145     175  3.62  2.77  15.5 V-sha~     5     6 manual medi~
##  9 Fiat 128   32.4  78.7    66  4.08  2.2   19.5 strai~     4     1 manual small
## 10 Fiat X1-9  27.3  79      66  4.08  1.94  18.9 strai~     4     1 manual small
## # ... with 22 more rows

Incluso podemos ordenar por grupos: vamos a seleccionar las variables model, mpg y am2, agruparemos según am2 y vamos a ordenar descendentemente según mpg y obtengamos el top 5 de vehículos con mejor rendimiento en millas recorridas por consumo de combustible:

mtcars2 %>% 
  select(model, mpg, am2) %>% 
  group_by(am2) %>% 
  arrange(desc(mpg), .by_group = TRUE) %>% 
  slice(1:5) %>% 
  ungroup() 
## # A tibble: 10 x 3
##    model            mpg am2      
##    <chr>          <dbl> <fct>    
##  1 Merc 240D       24.4 automatic
##  2 Merc 230        22.8 automatic
##  3 Toyota Corona   21.5 automatic
##  4 Hornet 4 Drive  21.4 automatic
##  5 Merc 280        19.2 automatic
##  6 Toyota Corolla  33.9 manual   
##  7 Fiat 128        32.4 manual   
##  8 Honda Civic     30.4 manual   
##  9 Lotus Europa    30.4 manual   
## 10 Fiat X1-9       27.3 manual

Se ha introducido una nueva función, slice que selecciona filas por posición, en este caso selecciona las filas de la 1 a la 5 en cada grupo. El argumento .by_group = TRUE es para que primero ordene por la variable de agrupación y luego por las demás que le paso.

relocate

Esta función es para cambiar la posición de las columnas. Por ejemplo, si quiero que hp esté luego de model y no luego de disp, puedo reordenar mi tibble usando relocate()

mtcars2 %>% 
  relocate(hp, .after=model)
## # A tibble: 32 x 12
##    model        hp   mpg  disp  drat    wt  qsec vs      gear  carb am2    cyl2 
##    <chr>     <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <dbl> <dbl> <fct>  <fct>
##  1 Mazda RX4   110  21    160   3.9   2.62  16.5 V-sha~     4     4 manual medi~
##  2 Mazda RX~   110  21    160   3.9   2.88  17.0 V-sha~     4     4 manual medi~
##  3 Datsun 7~    93  22.8  108   3.85  2.32  18.6 strai~     4     1 manual small
##  4 Hornet 4~   110  21.4  258   3.08  3.22  19.4 strai~     3     1 autom~ medi~
##  5 Hornet S~   175  18.7  360   3.15  3.44  17.0 V-sha~     3     2 autom~ big  
##  6 Valiant     105  18.1  225   2.76  3.46  20.2 strai~     3     1 autom~ medi~
##  7 Duster 3~   245  14.3  360   3.21  3.57  15.8 V-sha~     3     4 autom~ big  
##  8 Merc 240D    62  24.4  147.  3.69  3.19  20   strai~     4     2 autom~ small
##  9 Merc 230     95  22.8  141.  3.92  3.15  22.9 strai~     4     2 autom~ small
## 10 Merc 280    123  19.2  168.  3.92  3.44  18.3 strai~     4     4 autom~ medi~
## # ... with 22 more rows

Puedo hacerlo también usando un conjunto de variables, por ejemplo, moveré gear y carb después de mpg

mtcars2 %>% 
  relocate(gear, carb, .after=mpg)
## # A tibble: 32 x 12
##    model       mpg  gear  carb  disp    hp  drat    wt  qsec vs     am2    cyl2 
##    <chr>     <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <fct>  <fct>  <fct>
##  1 Mazda RX4  21       4     4  160    110  3.9   2.62  16.5 V-sha~ manual medi~
##  2 Mazda RX~  21       4     4  160    110  3.9   2.88  17.0 V-sha~ manual medi~
##  3 Datsun 7~  22.8     4     1  108     93  3.85  2.32  18.6 strai~ manual small
##  4 Hornet 4~  21.4     3     1  258    110  3.08  3.22  19.4 strai~ autom~ medi~
##  5 Hornet S~  18.7     3     2  360    175  3.15  3.44  17.0 V-sha~ autom~ big  
##  6 Valiant    18.1     3     1  225    105  2.76  3.46  20.2 strai~ autom~ medi~
##  7 Duster 3~  14.3     3     4  360    245  3.21  3.57  15.8 V-sha~ autom~ big  
##  8 Merc 240D  24.4     4     2  147.    62  3.69  3.19  20   strai~ autom~ small
##  9 Merc 230   22.8     4     2  141.    95  3.92  3.15  22.9 strai~ autom~ small
## 10 Merc 280   19.2     4     4  168.   123  3.92  3.44  18.3 strai~ autom~ medi~
## # ... with 22 more rows

Tal vez podría estar interesado en ordenar mi tibble en función del tipo de vaiables, decir, dejar todas numéricas juntas y todas las factor juntas:

mtcars2 <- mtcars2 %>% 
  relocate(where(is.factor), .before = where(is.numeric))

mtcars2
## # A tibble: 32 x 12
##    model     vs     am2    cyl2    mpg  disp    hp  drat    wt  qsec  gear  carb
##    <chr>     <fct>  <fct>  <fct> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4 V-sha~ manual medi~  21    160    110  3.9   2.62  16.5     4     4
##  2 Mazda RX~ V-sha~ manual medi~  21    160    110  3.9   2.88  17.0     4     4
##  3 Datsun 7~ strai~ manual small  22.8  108     93  3.85  2.32  18.6     4     1
##  4 Hornet 4~ strai~ autom~ medi~  21.4  258    110  3.08  3.22  19.4     3     1
##  5 Hornet S~ V-sha~ autom~ big    18.7  360    175  3.15  3.44  17.0     3     2
##  6 Valiant   strai~ autom~ medi~  18.1  225    105  2.76  3.46  20.2     3     1
##  7 Duster 3~ V-sha~ autom~ big    14.3  360    245  3.21  3.57  15.8     3     4
##  8 Merc 240D strai~ autom~ small  24.4  147.    62  3.69  3.19  20       4     2
##  9 Merc 230  strai~ autom~ small  22.8  141.    95  3.92  3.15  22.9     4     2
## 10 Merc 280  strai~ autom~ medi~  19.2  168.   123  3.92  3.44  18.3     4     4
## # ... with 22 more rows

Voy explicar qué sucedió ahí y qué significa el where, is.factor e is.numeric. where es un auxiliar que sirve para seleccionar variables según se indique a partir de una función que puede ser is.factor, is.character o is.numeric, el resultado de esas funciones le dicen a where dónde se ubican esas variables lo que luego es usado en relocate. Entonces, lo que entiende relocate es lo siguiente: “las variables que has identificado como factor, quiero que me las reubiqués antes de las variables que has identificado como numéricas” y lo que hace es, precisamente, ubicar todas las variables factor antes de las variables numéricas. Si hubiese otra variable de tipo diferente al final de la tabla, por ejemplo otra variable character, no la toca.

En este sentido, hay una forma más general de decirle cómo reordenar y es que tome todas las variables no numéricas (!where(is.numeric)es decir, negar las numéricas) y ubicarlas antes de las numéricas:

 mtcars2 %>% 
  relocate(!where(is.numeric), .before = where(is.numeric))
## # A tibble: 32 x 12
##    model     vs     am2    cyl2    mpg  disp    hp  drat    wt  qsec  gear  carb
##    <chr>     <fct>  <fct>  <fct> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4 V-sha~ manual medi~  21    160    110  3.9   2.62  16.5     4     4
##  2 Mazda RX~ V-sha~ manual medi~  21    160    110  3.9   2.88  17.0     4     4
##  3 Datsun 7~ strai~ manual small  22.8  108     93  3.85  2.32  18.6     4     1
##  4 Hornet 4~ strai~ autom~ medi~  21.4  258    110  3.08  3.22  19.4     3     1
##  5 Hornet S~ V-sha~ autom~ big    18.7  360    175  3.15  3.44  17.0     3     2
##  6 Valiant   strai~ autom~ medi~  18.1  225    105  2.76  3.46  20.2     3     1
##  7 Duster 3~ V-sha~ autom~ big    14.3  360    245  3.21  3.57  15.8     3     4
##  8 Merc 240D strai~ autom~ small  24.4  147.    62  3.69  3.19  20       4     2
##  9 Merc 230  strai~ autom~ small  22.8  141.    95  3.92  3.15  22.9     4     2
## 10 Merc 280  strai~ autom~ medi~  19.2  168.   123  3.92  3.44  18.3     4     4
## # ... with 22 more rows

rename

No sorprendería saber que esta función es para cambiar los nombres de las variables de nuestra base de datos, por ejemplo, renombremos la variable am2 por Transmission

mtcars2 %>% 
  rename(Transmision = am2)
## # A tibble: 32 x 12
##    model vs    Transmision cyl2    mpg  disp    hp  drat    wt  qsec  gear  carb
##    <chr> <fct> <fct>       <fct> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazd~ V-sh~ manual      medi~  21    160    110  3.9   2.62  16.5     4     4
##  2 Mazd~ V-sh~ manual      medi~  21    160    110  3.9   2.88  17.0     4     4
##  3 Dats~ stra~ manual      small  22.8  108     93  3.85  2.32  18.6     4     1
##  4 Horn~ stra~ automatic   medi~  21.4  258    110  3.08  3.22  19.4     3     1
##  5 Horn~ V-sh~ automatic   big    18.7  360    175  3.15  3.44  17.0     3     2
##  6 Vali~ stra~ automatic   medi~  18.1  225    105  2.76  3.46  20.2     3     1
##  7 Dust~ V-sh~ automatic   big    14.3  360    245  3.21  3.57  15.8     3     4
##  8 Merc~ stra~ automatic   small  24.4  147.    62  3.69  3.19  20       4     2
##  9 Merc~ stra~ automatic   small  22.8  141.    95  3.92  3.15  22.9     4     2
## 10 Merc~ stra~ automatic   medi~  19.2  168.   123  3.92  3.44  18.3     4     4
## # ... with 22 more rows

Verifique que, efectivamente, am2 pasó a llamarse Transmission, note que este cambio aún no ha sido incorporado a la tabla, porque no la he reemplazado con los nuevos cambios.

across

Esta función es muy conveniente para aplicar funciones (o conjunto de funciones) a un conjunto de columnas. Hay varias formas en las que se puede utilizar across y se puede combinar con varias alternativas. Vamos, primero a retomar is.numeric, porque ya la conocemos. Con ello podríamos resolver el siguiente objetivo: obtener el promedio de todas las variables numéricas de nuesta base de datos

mtcars2 %>% 
  summarise(across(where(is.numeric), mean))
## # A tibble: 1 x 8
##     mpg  disp    hp  drat    wt  qsec  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  20.1  231.  147.  3.60  3.22  17.8  3.69  2.81

Obtener la media y la desviación estándar de las variables cuyo nombre empieza con la letra h

mtcars2 %>% 
  summarise(across(starts_with("h"), list(mean = mean, sd = sd)))
## # A tibble: 1 x 2
##   hp_mean hp_sd
##     <dbl> <dbl>
## 1    147.  68.6

Convertir todas las variables factor a character:

mtcars2 %>% 
  mutate(across(where(is.factor), as.character))
## # A tibble: 32 x 12
##    model     vs     am2    cyl2    mpg  disp    hp  drat    wt  qsec  gear  carb
##    <chr>     <chr>  <chr>  <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4 V-sha~ manual medi~  21    160    110  3.9   2.62  16.5     4     4
##  2 Mazda RX~ V-sha~ manual medi~  21    160    110  3.9   2.88  17.0     4     4
##  3 Datsun 7~ strai~ manual small  22.8  108     93  3.85  2.32  18.6     4     1
##  4 Hornet 4~ strai~ autom~ medi~  21.4  258    110  3.08  3.22  19.4     3     1
##  5 Hornet S~ V-sha~ autom~ big    18.7  360    175  3.15  3.44  17.0     3     2
##  6 Valiant   strai~ autom~ medi~  18.1  225    105  2.76  3.46  20.2     3     1
##  7 Duster 3~ V-sha~ autom~ big    14.3  360    245  3.21  3.57  15.8     3     4
##  8 Merc 240D strai~ autom~ small  24.4  147.    62  3.69  3.19  20       4     2
##  9 Merc 230  strai~ autom~ small  22.8  141.    95  3.92  3.15  22.9     4     2
## 10 Merc 280  strai~ autom~ medi~  19.2  168.   123  3.92  3.44  18.3     4     4
## # ... with 22 more rows

Finalmente, Una forma abreviada de hacer esto es con mutate_if:

mtcars2 %>% 
  mutate_if(is.factor, as.character)
## # A tibble: 32 x 12
##    model     vs     am2    cyl2    mpg  disp    hp  drat    wt  qsec  gear  carb
##    <chr>     <chr>  <chr>  <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
##  1 Mazda RX4 V-sha~ manual medi~  21    160    110  3.9   2.62  16.5     4     4
##  2 Mazda RX~ V-sha~ manual medi~  21    160    110  3.9   2.88  17.0     4     4
##  3 Datsun 7~ strai~ manual small  22.8  108     93  3.85  2.32  18.6     4     1
##  4 Hornet 4~ strai~ autom~ medi~  21.4  258    110  3.08  3.22  19.4     3     1
##  5 Hornet S~ V-sha~ autom~ big    18.7  360    175  3.15  3.44  17.0     3     2
##  6 Valiant   strai~ autom~ medi~  18.1  225    105  2.76  3.46  20.2     3     1
##  7 Duster 3~ V-sha~ autom~ big    14.3  360    245  3.21  3.57  15.8     3     4
##  8 Merc 240D strai~ autom~ small  24.4  147.    62  3.69  3.19  20       4     2
##  9 Merc 230  strai~ autom~ small  22.8  141.    95  3.92  3.15  22.9     4     2
## 10 Merc 280  strai~ autom~ medi~  19.2  168.   123  3.92  3.44  18.3     4     4
## # ... with 22 more rows

Hasta aquí esta introducción a las funciones básicas de dplyr.

No hay comentarios:

Publicar un comentario