15-procesamiento_datos.Rmd

```{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.

&nbsp;

**`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>.
      
&nbsp;

**`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).

&nbsp;

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>

&nbsp;

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")`**

&nbsp;


**`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)
```


&nbsp;

## 📝 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>

&nbsp;


<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>


&nbsp;

<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>

&nbsp;

<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>

&nbsp;

<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>

&nbsp;