El presente documento contiene el solucionario a los ejercicios 10.5 del libro de R for Data Science de Hadley Wickham y Garrett Grolemund en su versión en español.
Este documento se realiza con fines académicos para el curso de Técnicas de Exploración de Datos de la carrera de Estadística e Informática de la Universidad Nacional Agraria La Molina de Lima, Perú.
Algunas funciones más antiguas no funcionan con los tibbles. Si te encuentras en uno de esos casos, usa as.data.frame() para convertir un tibble de nuevo en un data.frame:
class(as.data.frame(tb))
## [1] "data.frame"
La principal razón de que algunas funciones previas no funcionen con tibbles es la función [. En este libro no usamos mucho [ porque dplyr::filter() y dplyr::select() resuelven los mismos problemas con un código más claro (aprenderás un poco sobre ello en el capítulo sobre subjoncuntos de vectores). Con los data frames de R base, [ a veces devuelve un data frame y a veces devuelve un vector. Con tibbles, [ siempre devuelve otro tibble.
¿Cómo puedes saber si un objeto es un tibble? (Sugerencia: imprime mtautos en consola, que es un data frame clásico).
Para saber si un objeto es un tibble, usamos la función class(), para observar la funcionalidad de esta función, primero vamos a imprimir mtautos en nuestra consola.
mtautos # Observamos nuestro objeto
## millas cilindros cilindrada caballos eje peso velocidad
## Mazda RX4 21.0 6 160.0 110 3.90 2.620 16.46
## Mazda RX4 Wag 21.0 6 160.0 110 3.90 2.875 17.02
## Datsun 710 22.8 4 108.0 93 3.85 2.320 18.61
## Hornet 4 Drive 21.4 6 258.0 110 3.08 3.215 19.44
## Hornet Sportabout 18.7 8 360.0 175 3.15 3.440 17.02
## Valiant 18.1 6 225.0 105 2.76 3.460 20.22
## Duster 360 14.3 8 360.0 245 3.21 3.570 15.84
## Merc 240D 24.4 4 146.7 62 3.69 3.190 20.00
## Merc 230 22.8 4 140.8 95 3.92 3.150 22.90
## Merc 280 19.2 6 167.6 123 3.92 3.440 18.30
## Merc 280C 17.8 6 167.6 123 3.92 3.440 18.90
## Merc 450SE 16.4 8 275.8 180 3.07 4.070 17.40
## Merc 450SL 17.3 8 275.8 180 3.07 3.730 17.60
## Merc 450SLC 15.2 8 275.8 180 3.07 3.780 18.00
## Cadillac Fleetwood 10.4 8 472.0 205 2.93 5.250 17.98
## Lincoln Continental 10.4 8 460.0 215 3.00 5.424 17.82
## Chrysler Imperial 14.7 8 440.0 230 3.23 5.345 17.42
## Fiat 128 32.4 4 78.7 66 4.08 2.200 19.47
## Honda Civic 30.4 4 75.7 52 4.93 1.615 18.52
## Toyota Corolla 33.9 4 71.1 65 4.22 1.835 19.90
## Toyota Corona 21.5 4 120.1 97 3.70 2.465 20.01
## Dodge Challenger 15.5 8 318.0 150 2.76 3.520 16.87
## AMC Javelin 15.2 8 304.0 150 3.15 3.435 17.30
## Camaro Z28 13.3 8 350.0 245 3.73 3.840 15.41
## Pontiac Firebird 19.2 8 400.0 175 3.08 3.845 17.05
## Fiat X1-9 27.3 4 79.0 66 4.08 1.935 18.90
## Porsche 914-2 26.0 4 120.3 91 4.43 2.140 16.70
## Lotus Europa 30.4 4 95.1 113 3.77 1.513 16.90
## Ford Pantera L 15.8 8 351.0 264 4.22 3.170 14.50
## Ferrari Dino 19.7 6 145.0 175 3.62 2.770 15.50
## Maserati Bora 15.0 8 301.0 335 3.54 3.570 14.60
## Volvo 142E 21.4 4 121.0 109 4.11 2.780 18.60
## forma transmision cambios carburadores
## Mazda RX4 0 1 4 4
## Mazda RX4 Wag 0 1 4 4
## Datsun 710 1 1 4 1
## Hornet 4 Drive 1 0 3 1
## Hornet Sportabout 0 0 3 2
## Valiant 1 0 3 1
## Duster 360 0 0 3 4
## Merc 240D 1 0 4 2
## Merc 230 1 0 4 2
## Merc 280 1 0 4 4
## Merc 280C 1 0 4 4
## Merc 450SE 0 0 3 3
## Merc 450SL 0 0 3 3
## Merc 450SLC 0 0 3 3
## Cadillac Fleetwood 0 0 3 4
## Lincoln Continental 0 0 3 4
## Chrysler Imperial 0 0 3 4
## Fiat 128 1 1 4 1
## Honda Civic 1 1 4 2
## Toyota Corolla 1 1 4 1
## Toyota Corona 1 0 3 1
## Dodge Challenger 0 0 3 2
## AMC Javelin 0 0 3 2
## Camaro Z28 0 0 3 4
## Pontiac Firebird 0 0 3 2
## Fiat X1-9 1 1 4 1
## Porsche 914-2 0 1 5 2
## Lotus Europa 1 1 5 2
## Ford Pantera L 0 1 5 4
## Ferrari Dino 0 1 5 6
## Maserati Bora 0 1 5 8
## Volvo 142E 1 1 4 2
class(mtautos) # Obtenemos la clase del objeto
## [1] "data.frame"
Con la función class() obtuvimos que el objeto mtautos es una data frame clásico, ahora convertimos el data frame en un tibble.
mtautos_tibble <- as_tibble(mtautos)
class(mtautos_tibble) # Obtenemos la clase del objeto
## [1] "tbl_df" "tbl" "data.frame"
Para un tibble, class() debería retornar “tbl_df”, “tbl”, y “data.frame”.
mtautos_tibble # Observamos que efectivamente es un tibble
## # A tibble: 32 × 11
## millas cilindros cilindrada caballos eje peso velocidad forma transmision
## <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1 21 6 160 110 3.9 2.62 16.5 0 1
## 2 21 6 160 110 3.9 2.88 17.0 0 1
## 3 22.8 4 108 93 3.85 2.32 18.6 1 1
## 4 21.4 6 258 110 3.08 3.22 19.4 1 0
## 5 18.7 8 360 175 3.15 3.44 17.0 0 0
## 6 18.1 6 225 105 2.76 3.46 20.2 1 0
## 7 14.3 8 360 245 3.21 3.57 15.8 0 0
## 8 24.4 4 147. 62 3.69 3.19 20 1 0
## 9 22.8 4 141. 95 3.92 3.15 22.9 1 0
## 10 19.2 6 168. 123 3.92 3.44 18.3 1 0
## # ℹ 22 more rows
## # ℹ 2 more variables: cambios <dbl>, carburadores <dbl>
Compara y contrasta las siguientes operaciones aplicadas a un data frame y a un tibble equivalente. ¿Qué es diferente? ¿Por qué podría causarte problemas el comportamiento por defecto del data frame?
# Data Frame ----------------------------------------------------------------
df <- data.frame(abc = 1, xyz = "a")
# Tibble --------------------------------------------------------------------
tb <- tibble(abc = 1, xyz = "a")
# Data Frame ----------------------------------------------------------------
df$x
## [1] "a"
# Tibble --------------------------------------------------------------------
tb$x
## NULL
Observaciones:
Para un data frame, la operación df$x podría no devolver NULL, como en este caso, esto sucede porque x coincide parcialmente con el nombre de alguna columna existente y esa coincidencia es única. Este comportamiento puede ser útil en ciertos contextos pero también es potencialmente peligroso porque puede llevara errores difíciles de detectar, especialmente en data frames grandes con muchas columnas o cuando se modifican o actualizan los nombres de las columnas en el código.
Para un tibble, el acceso con tb$x resultará en un error si la columna x no existe, ya que los tibbles no permiten la coincidencia parcial de nombres de columnas cuando se accede a ellos de esta manera.Este es un diseño intencionado para evitar los problemas que pueden surgir con las coincidencias parciales en data.frames, donde podrías obtener una columna diferente a la esperada si no eres específico con el nombre.
# Data Frame ----------------------------------------------------------------
df[, "xyz"]
## [1] "a"
# Tibble --------------------------------------------------------------------
tb[, "xyz"]
## # A tibble: 1 × 1
## xyz
## <chr>
## 1 a
Observaciones:
Para un data frame, se obtiene el vector de la columna “xyz”. Por defecto, esta operación simplificará el resultado a la clase más simple posible; en este caso, un vector de caracteres.
Para un tibble preserva el tibble como resultado. Los tibbles tienen un comportamiento diferente, no simplifican el resultado, esto significa que, en lugar de devolver un vector, devolverá un tibble que contiene solo la columna xyz. Esta diferencia es significativa porque afecta cómo se manejan los datos subsiguientes.
# Data Frame ----------------------------------------------------------------
df[, c("abc", "xyz")]
## abc xyz
## 1 1 a
# Tibble --------------------------------------------------------------------
tb[, c("abc", "xyz")]
## # A tibble: 1 × 2
## abc xyz
## <dbl> <chr>
## 1 1 a
Observaciones:
En un data frame seleccionará ambas columnas abc y xyz del data.frame, devolviendo otro data.frame.
En un tibble se seleccionará ambas columnas y devolviendo otro tibble.
Simplificación automática: Los data frames simplificarán automáticamente el resultado a la clase más básica posible cuando se extrae una sola columna (a menos que se especifique drop = FALSE), mientras que los tibbles no lo hacen. Esto puede causar confusión o errores inesperados en el código si se espera un data frame o tibble y se obtiene un vector.
Nombres parciales: Los data frames permiten el uso de nombres de columnas parciales con el operador $, lo cual puede ser conveniente pero también riesgoso si no se maneja con cuidado, ya que puede llevar a errores difíciles de detectar si los nombres de las columnas cambian o si se agregan nuevas columnas que coincidan parcialmente con los nombres existentes. Los tibbles no permiten este comportamiento, lo cual es más seguro y predecible.
Compatibilidad con tipos y estructuras: Al trabajar con tibbles, puedes esperar una mayor consistencia en el manejo de tipos de datos y estructuras de datos. Los data frames pueden tener comportamientos inesperados debido a la conversión automática de tipos o la simplificación de estructuras.
Si tienes el nombre de una variable guardada en un objeto, p.e., var <- “mpg”, ¿cómo puedes extraer esta variable de un tibble?
Para extraer una variable (columna) de un tibble en R, se puede usar diferentes métodos, como el operador [[, o la función pull() o select() de dplyr, a continuación se mostrará un ejemplo con cada uno de estos métodos.
df <- tibble(
mpg = c(1, 2, 3),
abc = c(44, 55, 66),
def = c(777, 888, 999))
# Nombre de la variable almacenado en un objeto
var <- "mpg"
variable_tb1 <- df[[var]] # Devuelve como vector
variable_tb1
## [1] 1 2 3
variable_tb2 <- pull(df, var) # Devuelve como vector
variable_tb2
## [1] 1 2 3
variable_tb3 <- select(df, var) # Devuelve un tibble ("select" devuelve un objeto
# del mismo tipo que el objeto de entrada, ya
# sea un data frame o un tibble.)
variable_tb3
## # A tibble: 3 × 1
## mpg
## <dbl>
## 1 1
## 2 2
## 3 3
No podemos extraer la variable del tibble, con el operador “$”, esto debido a que el operador $ espera un nombre de columna literal, no una variable que contenga el nombre de la columna. Es decir, cuando haces df$var, R busca literalmente una columna llamada “var” en tu tibble df, la cual no existe, y por eso te da el mensaje de advertencia y NULL como resultado.
variable_tb4 <- df$var
variable_tb4
## NULL
Practica referenciar nombres no sintácticos en el siguiente data frame:
molesto <- tibble(
`1` = 1:10,
`2` = `1` * 2 + rnorm(length(`1`)))
molesto
## # A tibble: 10 × 2
## `1` `2`
## <int> <dbl>
## 1 1 4.25
## 2 2 3.83
## 3 3 5.49
## 4 4 7.81
## 5 5 8.67
## 6 6 12.8
## 7 7 14.6
## 8 8 15.9
## 9 9 18.4
## 10 10 20.1
columna1 <- select(molesto, `1`)
columna1
## # A tibble: 10 × 1
## `1`
## <int>
## 1 1
## 2 2
## 3 3
## 4 4
## 5 5
## 6 6
## 7 7
## 8 8
## 9 9
## 10 10
ggplot(molesto, aes(x = `1`, y = `2`)) +
geom_point() + theme_bw() +
labs(x = "1", y = "2", title = "Gráfico de dispersión de 1 vs 2")
molesto <- molesto %>%
mutate(`3` = `2` / `1`)
molesto %>%
rename(uno = `1`, dos = `2`, tres = `3`)
## # A tibble: 10 × 3
## uno dos tres
## <int> <dbl> <dbl>
## 1 1 4.25 4.25
## 2 2 3.83 1.92
## 3 3 5.49 1.83
## 4 4 7.81 1.95
## 5 5 8.67 1.73
## 6 6 12.8 2.13
## 7 7 14.6 2.09
## 8 8 15.9 1.99
## 9 9 18.4 2.04
## 10 10 20.1 2.01
¿Qué hace tibble::enframe()? ¿Cuándo lo usarías?
La función tibble::enframe() convierte un vector, una lista o un objeto similar en un tibble (un tipo de data frame moderno proporcionado por el paquete tibble en R).
library(tibble)
vec <- c(a = 1, b = 2, c = 3)
enframe(vec)
## # A tibble: 3 × 2
## name value
## <chr> <dbl>
## 1 a 1
## 2 b 2
## 3 c 3
Emplearía tibble::enframe() cuando necesite trabajar con datos que están en forma de vector o lista pero requieren ser manejados o analizados como tibble. Algunas situaciones de su uso incluirían:
Análisis de Datos: Cuando se quiere aplicar filtraciones, mutaciones, o cualquier otra operación típica de manipulación de datos.
Visualización: Convertir datos en un formato que pueda ser fácilmente visualizado usando paquetes que trabajan mejor con data frames o tibbles, como ggplot2.
Interoperabilidad: Cuando necesitas pasar datos a funciones o paquetes que esperan un data frame/tibble en lugar de un vector o lista.
Transformación de Datos: Para transformar y organizar datos que originalmente vienen en vectores o listas en una estructura que facilita su exploración y análisis.
En resumen, tibble::enframe() es una herramienta conveniente para la transformación de estructuras de datos básicas de R en tibbles, facilitando su manipulación y análisis dentro del ecosistema de tidyverse.
¿Qué opción controla cuántos nombres de columnas adicionales se muestran al pie de un tibble?
Se sabe que los tibbles por defecto muestran solo las primeras 10 filas y las columnas que caben en la ventana de la consola. Para controlar la visualización de columnas de un tibble, se puede usar:
Muestra todas las columnas.
vuelos %>%
print(width = Inf)
## # A tibble: 336,776 × 19
## anio mes dia horario_salida salida_programada atraso_salida
## <int> <int> <int> <int> <int> <dbl>
## 1 2013 1 1 517 515 2
## 2 2013 1 1 533 529 4
## 3 2013 1 1 542 540 2
## 4 2013 1 1 544 545 -1
## 5 2013 1 1 554 600 -6
## 6 2013 1 1 554 558 -4
## 7 2013 1 1 555 600 -5
## 8 2013 1 1 557 600 -3
## 9 2013 1 1 557 600 -3
## 10 2013 1 1 558 600 -2
## horario_llegada llegada_programada atraso_llegada aerolinea vuelo codigo_cola
## <int> <int> <dbl> <chr> <int> <chr>
## 1 830 819 11 UA 1545 N14228
## 2 850 830 20 UA 1714 N24211
## 3 923 850 33 AA 1141 N619AA
## 4 1004 1022 -18 B6 725 N804JB
## 5 812 837 -25 DL 461 N668DN
## 6 740 728 12 UA 1696 N39463
## 7 913 854 19 B6 507 N516JB
## 8 709 723 -14 EV 5708 N829AS
## 9 838 846 -8 B6 79 N593JB
## 10 753 745 8 AA 301 N3ALAA
## origen destino tiempo_vuelo distancia hora minuto fecha_hora
## <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dttm>
## 1 EWR IAH 227 1400 5 15 2013-01-01 05:00:00
## 2 LGA IAH 227 1416 5 29 2013-01-01 05:00:00
## 3 JFK MIA 160 1089 5 40 2013-01-01 05:00:00
## 4 JFK BQN 183 1576 5 45 2013-01-01 05:00:00
## 5 LGA ATL 116 762 6 0 2013-01-01 06:00:00
## 6 EWR ORD 150 719 5 58 2013-01-01 05:00:00
## 7 EWR FLL 158 1065 6 0 2013-01-01 06:00:00
## 8 LGA IAD 53 229 6 0 2013-01-01 06:00:00
## 9 JFK MCO 140 944 6 0 2013-01-01 06:00:00
## 10 LGA ORD 138 733 6 0 2013-01-01 06:00:00
## # ℹ 336,766 more rows
Establece una opción global que controla el ancho máximo para la impresión de tibbles.
options(tibble.width = 80)
vuelos
## # A tibble: 336,776 × 19
## anio mes dia horario_salida salida_programada atraso_salida
## <int> <int> <int> <int> <int> <dbl>
## 1 2013 1 1 517 515 2
## 2 2013 1 1 533 529 4
## 3 2013 1 1 542 540 2
## 4 2013 1 1 544 545 -1
## 5 2013 1 1 554 600 -6
## 6 2013 1 1 554 558 -4
## 7 2013 1 1 555 600 -5
## 8 2013 1 1 557 600 -3
## 9 2013 1 1 557 600 -3
## 10 2013 1 1 558 600 -2
## # ℹ 336,766 more rows
## # ℹ 13 more variables: horario_llegada <int>, llegada_programada <int>,
## # atraso_llegada <dbl>, aerolinea <chr>, vuelo <int>, codigo_cola <chr>,
## # origen <chr>, destino <chr>, tiempo_vuelo <dbl>, distancia <dbl>,
## # hora <dbl>, minuto <dbl>, fecha_hora <dttm>
En este caso,esta configuración ajusta cómo los tibbles se visualizan en la consola, intentando limitar la representación de los mismos a un máximo de 80 caracteres de ancho.