```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

Hay muchas operaciones que se pueden hacer en una base de datos, a continuación veremos algunas de las operaciones básicas además de la transformación de formatos largo a ancho y viceversa.

Para este tutorial utilizaremos una base de datos disponible en todas las versiones de R que se llama `mtcars`. Para importarla al espacio de trabajo necesitamos correr el siguiente código:

```{r echo = T}
data("mtcars")
```

Esta base de datos contiene información sobre características físicas y consumo de combustible de automóviles vendidos en Estados Unidos. Sobre esta base de datos haremos las siguientes operaciones:

1. Extraer columnas
2. Extraer filas condicionalmente
3. Separar y unir tablas
4. Ordenar de acuerdo con los valores de alguna columna
5. Agrupar de acuerdo con alguna variable categórica

Para este ejercicio utilizaremos el paquete `plyr`, y si no lo tienen instalado se puede hacer con el siguiente código:

```{r echo = T, eval = F}
install.packages("plyr")
```

# Extraer columnas

Para esta operación utilizaremos la función `subset` que quiere decir subconjunto. Para poder realizar esta operación necesitamos conocer los nombres de las columnas de la base `mtcars` mediante la función `names`:

```{r echo = F}
names(mtcars)
```

Para conocer el significado de cada una de las variables se puede consutar la ayuda de R:

```{r echo = T, eval = F}
?mtcars
```

Entonces para crear una tabla subconjunto de `mtcars` que contenga las variables `mpg` (millas por galón), `cyl` (número de cilindros) y `hp` (caballos de fuerza), corremos el código siguiente:

```{r echo = TRUE}
mtcars.1 <- subset(mtcars, select = c("mpg", "cyl", "hp"))
```

El prier argumento es la nombre del objeto que contiene la tabla que queremos procesar (`mtcars`), el segundo argumento, `select` es una cadena de caracteres que contenga los nombres de las columnas que queremos extraer (resultado en tabla \@ref(tab:mtcars1)).

```{r mtcars1, echo = F}
knitr::kable(head(mtcars.1), caption = "Primeras seis columnas de la tabla subconjunto de `mtcars` con las columnas `mpg`, `cyl` y `hp`.")
```

Como resulta evidente, el resultado es otra tabla, con el mismo formato pero que sólo contiene las columnas que indicamos a la función `subset`

# Extraer filas condicionalmente

Al igual que ya extrajimos sólo una fracción de las columnas podemos extraer filas. Al decir condicionalmente nos referimos a que necesitamos identificar un criterio para extraer las filas. Por ejemplo, la variable `vs` indica si un vehículo tiene motor en v (0) ó en línea (1). Entonces si deseamos crear una base que contenga sólo los datos para vehículos con motor en v:

```{r echo = T}
mtcars.vs <- subset(mtcars, vs == 0)
```

la condición para crear el subconjunto es que la variable `vs` valga `0`. El operador `==` es de tipo lógico e indica igual a. Otros operadores lógicos son:

1. `!=`, diferente de
2. `>`, mayor que
3. `<`, menor que

Por lo tanto, las siguientes son algunas alternativas para hacer la misma operación:

```{r echo=T, eval=F}
subset(mtcars, vs != 1)
subset(mtcars, vs < 1)
```

Asimismo, es posible utilizsar más de un criterio de manera simultánea, por ejemplo extrayendo las filas donde `vs == 0` y `am == 1` (automático--0-- o manual--1):

```{r echo = T}
mtcars.2 <- subset(mtcars, vs == 0 & am == 1)
```

# Separar y unir tablas

En ocasiones es necesario capturar datos en tablas separadas, de modo que aprender a unirlas es una habilidad importante. Hay diferentes maneras de unir tablas:

1. Añadir columnas
2. Añadir filas

## Unir columnas

Al efectuar esta operación estamos introduciendo variables nuevas a una tabla, y por lo tanto nuevas descripciones de nuestras unidades observacionales. Por lo tanto es de suma importancia que las filas coincidan para cada una de las unidades y que ambas tablas a unir tengan el mismo número de filas. Por ejemplo, si hubiésemos capturado la base `mtcars` en dos tablas separadas, tenemos que asegurarnos de que la fila 1 de ambas bases contenga la información necesaria del vehículo `Mazda RX4`. Las tablas \@ref(tab:mtcarsl) y \@ref(tab:mtcarsd) muestran a `mtcars` dividida en dos.

```{r mtcarsl, echo = F}
mtcars.l <- mtcars[,1:5]
mtcars.d <- mtcars[, 6:10]
knitr::kable(head(mtcars.l), caption = "Primeras seis filas de de las primeras cinco columnas de `mtcars`.")
```

```{r mtcarsd, echo = F}
knitr::kable(head(mtcars.d), caption = "Primeras seis filas de las últimas cinco columnas de `mtcars`.")
```

Para unir estas dos tablas, podemos utilizar la función `cbind`, que quiere decir *column bind* (unir columnas):

```{r echo = T}
mtcars.f <- cbind(mtcars.l, mtcars.d)
```

Los argumentos que se utilizan en `cbind` son todas las tablas que querramos unir en una misma base de datos.

## Unir filas

Así como en la adición de columnas teníamos que asegurarnos de tener el mismo número de filas, para añadir filas tenemos que asegurarnos de tener el mismo número de columnas, de modo que las variables que continene cada una de las tablas sean las mismas y en el mismo orden. La función que realiza esta operación es `rbind`, y funciona de la misma manera que `cbind`:

```{r echo = T, eval = F}
mtcars.f2 <- rbind(mtcars.t, mtcars.b)
```

# Ordenar de acuerdo con valores

En frecuente que las bases de datos no sigan un órden lógico, a menos que hayan sido colectadas de manera secuencia como en una línea temporal. Por lo tanto es de suma utilidad saber cómo se puede ordenar una base de datos. Como es de esperarse, se debe cumplir que el criterio de ordenamiento, debe afectar a todas las columnas, de modo que no se mezcle la información que corresponde con individuos distintos. Aquí cabe hacer una advertencia, y es que ordenar una columna es un ejercicio muy sencillo, que se puede hacer en Excel, sin embargo, por defecto el orden sólo se aplica a una columna lo que invalida toda la base de datos.

Para ordenar una tabla en R utilizaremos el paquete `plyr`. Para instalarlo podemos ejecutar la siquiente línea de código:

```{r echo = T, eval = F}
install.packages("dplyr")
```

Y para abrirlo una vez instalado:

```{r echo = T, message=F, warning=F}
library(dplyr)
```

El paquete `dplyr` utiliza una sintaxis un tanto diferente de muchos paquetes de R. Normalmente, se llama la función y dentro de los paréntesis se indica al objeto que se procesará. En este caso, primero se llama el objeto (`mtcars`, por ejemplo) y después se indica la función que se aplicará al objeto y los argumentos siguientes depués del operador `%>%`. La función que ordena una tabla es `arrange`:

```{r echo = T}
mtcars.desc <- mtcars %>% arrange(desc(mpg))
```

donde hemos creado un nuevo objeto `mtcars.desc` ordenado de mayor a menor (descendiente) con base en la columna `mpg`. Para ordenar ascendentemente (tabla \@ref(tab:mtcarsdesc)):

```{r echo = T}
mtcars.asc <- mtcars %>% arrange(mpg)
```

```{r mtcarsdesc, echo = F}
knitr::kable(head(mtcars.desc), caption = "Base de datos `mtcars` ordenada con base en la columna `mpg` de mayor a menor.")
```

Este método, puede aplicarse con más de una columna en mente, priorizando de izquierda a derecha:

```{r echo = T}
mtcars.ord1 <- mtcars %>% arrange(mpg, desc(hp))
```

# Agrupar de acuerdo con una variable categórica

Las bases de datos se pueden resumir de algunas maneras, por ejemplo en `mtcars` podríamos calcular el consumo promedio de combustible de los vehículos con 4, 6 y 8 cilindros. Además del promedio también podríamos obtener la desviación estándar. No son operaciones complicadas, pero cuando la base de datos es grande, hacerlo a mano puede requerir de mucho tiempo. Afortunadamente, contamos con `dplyr` para ejecutar esta opeación de manera eficiente, con la función `group_by` y `summarise` (tabla \@ref(tab:mtcarsprom)):

```{r echo = T}
mtcars.prom <- mtcars %>% group_by(cyl) %>% summarise(mpg = mean(mpg), hp = mean(hp))
```

```{r mtcarsprom, echo = F}
knitr::kable(mtcars.prom, caption = "Base `mtcars` agrupada por número de cilindros en las columnas `mpg` y `hp`.") 
```

[Código fuente de este tutorial](Procesamiento-datos.Rmd)

[Regresar al índice del curso](index.html)
