-
Notifications
You must be signed in to change notification settings - Fork 2
/
15-procesamiento_datos.Rmd
308 lines (201 loc) · 9.97 KB
/
15-procesamiento_datos.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
```{r echo = FALSE}
library(knitr)
# Color text
colorize <- function(x, color) {
if (knitr::is_latex_output()) {
sprintf("\\textcolor{%s}{%s}", color, x)
} else if (knitr::is_html_output()) {
sprintf("<span style='color: %s;'>%s</span>", color, x)
} else { x }
}
```
# (PART) Empezando a explorar datos{-}
# Mejorando los data.frame: datos tibble {#tibble}
:::: {.blackbox data-latex=""}
Scripts usados:
* [**script15.R**](https://github.com/dadosdelaplace/courses-ECI-2022/blob/main/scripts/script15.R): datos tibble. Ver en <https://github.com/dadosdelaplace/courses-ECI-2022/blob/main/scripts/script15.R>
::::
Empieza lo interesante :)
```{r flujo-tidy-data, echo = FALSE, out.width = "60%", fig.align = "center", fig.cap = "Flujo deseable de datos según Hadley Wickham, extraída de <https://r4ds.had.co.nz/wrangle-intro.html>"}
knitr::include_graphics("./img/flujo_tidy_data.jpg")
```
Fíjate bien en el anterior **flujo de trabajo**: vamos a intentar tener unas nociones básicas para <mark>**preparar los datos**</mark>, y después veremos <mark>**distintas formas de importarlos y guardarlos**</mark>. Antes vamos a repasar los tipos de datos que hemos hasta ahora. <mark>**¿Existen más tipos de datos de los que ya conocemos?**</mark>
La respuesta te la estarás imaginando: sí. De hecho no es solo que existan más, sino que **puedes crear tus propios tipos de datos**, pero seguramente acabarán siendo, en su nivel más profundo, una combinación de alguna de las estructuras que ya conocemos. El objetivo de este curso es empezar a ser autónomo/a en el análisis de datos, así que (de momento) vamos a quedarnos como estamos.
**`r colorize("GLOSARIO:", "#4197D2")`**
Si es importante entender las diferencias entre los datos que ya hemos definido.
* **`r colorize("Vectores", "#4197D2")`**: es el tipo de dato más simple, una colección de valores pero del <mark>**mismo tipo**</mark>. Los vectores pueden ser de longitud 1 (valores individuales a secas), una **colección de números**, una **colección de cadenas de texto** o una **colección de valores lógicos** (pudiendo tener dentro datos ausentes, o valores especiales como `Inf` o `NaN`)
* **`r colorize("Matrices", "#4197D2")`**: se pueden entender como una especie de colección de vectores, una colección de colecciones, un tipo de dato <mark>**bidimensional**</mark>. Una matriz se conforma de filas y columnas pero, de nuevo, los datos deben ser del <mark>**mismo tipo y longitud**</mark>, los vectores concatenados que forma las filas y/o columnas.
* **`r colorize("data.frame", "#4197D2")`**: son datos estructurados, lo que comunmente conocemos como «tablas». A diferencia de las matrices, aunque deben <mark>**seguir teniendo la misma longitud**</mark>, las variables que lo conforman pueden ser de <mark>**tipos diferentes**</mark>, puediendo tener el mismo conjunto de datos numéricos, caracteres, lógicos, etc.
* **`r colorize("Listas", "#4197D2")`**: las listas son una concatenación de elementos, a secas, de forma que nos permite concatenar cualquier tipo de dato anterior, pudiendo ser de <mark>**diferente longitud y diferente tipo**</mark>.
**`r colorize("WARNING: cuidado con las listas", "#ffc107")`**
Como hemos mencionado, una **`r colorize("lista no se puede vectorizar de forma inmediata", "#ffc107")`**, por lo cualquier operación aritmética aplicada a una lista dará error. Para poder operar con ellas tenemos una opción que es aplicar la función `lapply()`, o directamente acudir al paquete `{purrr}` (te animo a investigar en dicho paquete).
Antes de preparar nuestros datos, vamos a ver un tipo de dato que quizás hayamos mencionado por encima: las <mark>**tablas `tibble`**</mark>. Los datos en formato `tibble` (del paquete `{tibble}`) son un tipo de `data.frame` mejorado, para una gestión más ágil, eficiente y coherente. Las <mark>**tablas en formato tibble**</mark> (su clase será _tbl_df_) tienen 4 ventajas principales frente a los ya vistos `data.frame`:
* Permiten <mark>**imprimir por consola la tabla con mayor información**</mark> de las variables, y **solo imprime por defecto las primeras filas** (todas si son 20 o menos, 10 si son más de 20 filas).
```{r}
library(tibble)
# data.frame
tabla_df <-
data.frame("x" = 1:50,
"y" = rep(c("a", "b", "c", "d", "e"), 10),
"z" = 11:60,
"logica" = rep(c(TRUE, TRUE, FALSE, TRUE, FALSE), 10))
tabla_df
# tibble
tabla_tb <- tibble("x" = 1:50,
"y" = rep(c("a", "b", "c", "d", "e"), 10),
"z" = 11:60,
"logica" = rep(c(TRUE, TRUE, FALSE, TRUE, FALSE), 10))
tabla_tb
```
Puedes imprimir las filas y columnas que quieras con `print()`, pero por defecto te aseguras de **no saturar la consola**.
```{r}
print(tabla_tb, n = 13, width = Inf)
```
* Mantiene la <mark>**integridad de los datos**</mark> (no cambia los tipos de las variables y hace una carga de datos inteligente, interpretando las fechas como tal, por ejemplo).
* La **función `tibble()` construye las variables secuencialmente**, pudiendo hacer uso en la propia definición de variables recién definidas en dicha definición.
```{r error = TRUE}
# data.frame
data.frame("x" = 1:5,
"y" = c("a", "b", "c", "d", "e"),
"z" = 11:15,
"logica" = c(TRUE, TRUE, FALSE, TRUE, FALSE),
"x*z" = x * z)
# tibble
tibble("x" = 1:5,
"y" = c("a", "b", "c", "d", "e"),
"z" = 11:15,
"logica" = c(TRUE, TRUE, FALSE, TRUE, FALSE),
"x*z" = x * z)
```
* Si **accedes a una columna que no existe avisa** con un warning.
```{r warning = TRUE, error = TRUE}
# data.frame
tabla_df$variable_inexistente
# tibble
tabla_tb$variable_inexistente
```
* No solo no te cambiará el tipo de datos sino que **no te cambiará el nombre de las variables** (los `data.frame` transforma los caracteres que no sean letras).
```{r}
# data.frame
data.frame(":)" = "emoticono", " " = "en blanco", "2000" = "número")
# tibble
tibble(":)" = "emoticono", " " = "en blanco", "2000" = "número")
```
* Realiza una <mark>**carga de los datos más ágil**</mark>
Puedes <mark>**consultar**</mark> más funcionalidades de dichos datos en <https://tibble.tidyverse.org/> pero están son las principales ventajas.
Una de ellas es la <mark>**función `glimpse()`**</mark>, que nos permite obtener el <mark>**resumen de columnas**</mark> (no es para tener un resumen de los datos sino para ver las variables que tenemos y su tipo).
```{r}
glimpse(tabla_tb)
```
## Consejos
**`r colorize("CONSEJOS", "#20935E")`**
**`r colorize("Convertir a tibble", "#20935E")`**
Si ya tienes un `data.frame` es altamente recomendable convertirlo a tibble con `as_tibble()` (del paquete `{dplyr}`)
```{r}
library(dplyr)
as_tibble(tabla_df)
```
## 📝 Ejercicios
(haz click en las flechas para ver soluciones)
<details>
<summary>📝<strong>Ejercicio 1</strong>: ¿es el conjunto de datos `airquality` (del paquete `{datasets}`) de tipo `tibble`? </summary>
<!-- toc -->
- Solución:
Recuerda que podemos cargar elementos de un paquete (en este caso `{datasets}`) cargando `library(datasets)` y luego el elemento, o bien `datasets::airquality` (prefijo::nombre).
La respuesta: NO. Tienes muchas formas de comprobarlo si imprimes el conjunto por defecto.
```{r}
library(datasets)
airquality
class(airquality)
```
- Imprime por defecto todas las filas (tiene 153 filas, debería imprimir solo 10 si fuese un tibble, para no saturar consola).
- No especifica al imprimir que es de tipo `tibble`.
- No especifica al imprimir el tipo de dato de las columnas.
- Imprime el nombre de las filas (el nombre de los modelos) como si fuera una variable (¡que no existe!).
<!-- tocstop -->
</details>
<details>
<summary>📝<strong>Ejercicio 2</strong>: convierte el conjunto `airquality` de `data.frame` a `tibble`. </summary>
<!-- toc -->
- Solución:
Así debería de salir si fuera `tibble`.
```{r}
library(dplyr)
airquality_tb <- as_tibble(airquality)
airquality_tb
class(airquality_tb)
```
<!-- tocstop -->
</details>
<details>
<summary>📝<strong>Ejercicio 3</strong>: define un `tibble` con tres variables numéricas `a, b, c`, tal que la tercera sea el producto de las dos primeras `c = a * b`<mark>. Inténtalo hacer con un `data.frame`</summary>
<!-- toc -->
- Solución:
Un ejemplo:
```{r}
tibble("a" = 1:7, "b" = 11:17, "c" = a * b)
```
Si lo intentamos con un `data.frame`, intentará buscar una variable real que tengamos guardada que se llame `a` y `b`, sin encontrarlas.
```{r error = TRUE}
data.frame("a" = 1:7, "b" = 11:17, "c" = a * b)
```
<!-- tocstop -->
</details>
<details>
<summary>📝<strong>Ejercicio 4</strong>: define un `tibble` con tres variables de nombres `variable`, `2`, `tercera :)`, e intenta acceder a ellas.</summary>
<!-- toc -->
- Solución:
Las variables solo con caracteres del alfabeto se podrán acceder sin necesidad de comillas.
```{r}
# Definimos el tibble
datos_tb <- tibble("variable" = 1:7, "tercera falsa :)" = 0,
"2" = 11:17)
# Accedemos a sus columnas
datos_tb$variable
datos_tb$`tercera falsa :)`
datos_tb$`2`
```
También se puede acceder por el orden que ocupan:
```{r}
datos_tb[1]
datos_tb[2]
datos_tb[3]
```
Y también por el nombre entre corchetes (doble corchete extrae la variable fuera del tibble, corchete simple en formato tibble):
```{r}
datos_tb["variable"]
datos_tb[["variable"]]
datos_tb["tercera falsa :)"]
datos_tb["2"]
```
<!-- tocstop -->
</details>
<details>
<summary>📝<strong>Ejercicio 5</strong>: obten de los paquetes `{dplyr}` y `{gapminder}` los conjuntos de datos tibble `starwars` y `gapminder`. Comprueba el número de variables, de registros e imprime los datos</summary>
<!-- toc -->
- Solución:
```{r}
# starwars
library(dplyr)
starwars
glimpse(starwars) # resumen de columnas
dim(starwars) # dimensiones
# gapminder
library(gapminder)
gapminder
glimpse(gapminder) # resumen de columnas
dim(gapminder) # dimensiones
```
<!-- tocstop -->
</details>