r-intro.rmd

---
title: "Introducción a R"
---

```{r setup, echo = FALSE}
knitr::opts_chunk$set(message = FALSE, comment = "#>")
```

# **Qué es R?**

## **Qué es R?**

### **El software estadístico más poderoso y usado en el mundo**

<!--html_preserve-->
<br>

<div class="videowrapper">
  <iframe src="https://www.youtube.com/embed/NZPHiYP7I24?cc_load_policy=1&cc_lang_pref=es" frameborder="0" allowfullscreen></iframe>
</div>
<!--/html_preserve-->

## [Qué es R?](http://www.r-project.org/about.html)

> *"R is a language and environment for statistical computing and graphics."*

Entre otras cosas R incluye:

  - capacidad para almacenar y manipular datos **efectivamente**
  - un conjunto de operadores para hacer cálculos sobre arreglos, particularmente matrices
  - una colección grande, **coherente** e integrada de herramientas para el análisis de datos
  - dispositivos gráficos para el análisis y visualización de datos, tanto en pantalla como en impreso
  - un lenguaje de programación bien desarrollado, **simple y eficaz**

## Qué es R?

Un poco más en realidad:

- Una gran comunidad mundial.
- El laboratorio de **muchos** estadísticos y científicos de datos.
- El principal medio para el desarrollo y la [divulgación](http://journal.r-project.org/)
  de técnicas estadísticas y de análisis de datos de vanguardia.
- Jhon Chambers, miembro del equipo de R y co-autor de S, el lenguaje del cual se
  deriva R, lo describe como una
  [**interfaz**](https://www.youtube.com/watch?v=_hcpuRB5nGs): un portal a todo
  tipo de herramientas/algoritmos.

# Setup

## Setup {.build}

La página principal de R es [r-project.org](http://www.r-project.org).

Hay instaladores para Windows y MacOS disponibles. R hace parte de varias
distribuciones de Linux y se puede instalar fácilmente con los manejadores de
paquetes.

Básicamente lo primero que aparece en el *Comprehensive R Archive Network*
(CRAN): [cran.r-project.org](http://www.cran.r-project.org)

En Mac también se puede instalar R con [brew](https://github.com/Homebrew/homebrew/tree/master/share/doc/homebrew#readme)
(recomendado):

        brew install homebrew/science/r

## Empezando con R

<!--html_preserve-->
<div class="videowrapper">
  <iframe src="http://giphy.com/embed/nkLB4Gp8H6hFe?html5=true" width="40" height="22.5" frameBorder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>
</div>
<!--/html_preserve-->

## Setup

Aprender a usar R puede ser (muy) frustrante.

Interfaces:

- En Windows y Mac R viene con un GUI
- IDE: [RStudio](www.rstudio.com)
- R Commander [Rcmdr](http://socserv.socsci.mcmaster.ca/jfox/Misc/Rcmdr/)
  un GUI para R con funcionalidades estadísticas básicas.

Igualmente Emacs y Vim tienen plugins:

- [Emacs Speaks Statistics](http://ess.r-project.org)
- [Vim-R-Plugin](http://www.vim.org/scripts/script.php?script_id=2628)

## Ayuda para empezar {.build}

Por dónde empezar?

Desde R:

```{r eval = FALSE}
help.start()
```

o desde RStudio en _Help_ o simplemente desde el [CRAN](http://www.cran.r-project.org) llegamos al [Manual Introductorio](http://cran.rstudio.org/doc/manuals/r-release/R-intro.pdf).

Este manual se encuentra [en español](http://cran.r-project.org/doc/contrib/R-intro-1.1.0-espanol.1.pdf) en la sección de [documentación contribuida](http://cran.r-project.org/other-docs.html) donde hay **mucho** material.

# El lenguaje

## Hola Mundo! {.build}

```{r}
"Hola mundo!"
# Esto es un comentario

y <- 2 + 2         # Asignación
y^y / 10*pi + 1    # Expresión
matrix(1, nrow = y/2, ncol = y)
```

## Rudimentos del lenguaje {.build}

Usamos `<-` (o `=`) para _asignar_ y `#` para iniciar un comentario.

```{r eval = FALSE}
y <- 2 + 2    # Asignación
```

`matrix()` es una función, entre paréntesis van sus argumentos (los podemos especificar por posición, por nombre o por **omisión**).

```{r eval = FALSE}
matrix(data = 1, y/2, y)
```

Para explorar un objeto o variable usamos la funcion `str()` (_e_**str**_uctura_)
```{r}
str(matrix(data = 1, y/2, y))
```

Para ver la ayuda de una función la precedemos con un `?`.

## Estructuras de datos {.build .left-margin}

### Vectores atómicos

```{r vectores}
logico   <- c(TRUE, FALSE, T)
entero   <- c(1L, 6L, 10L)
doble    <- c(a = 1, b = 2.5, c = 4.5)
caracter <- c("Hola", "mundo", "!")
```

### Vectores recursivos

```{r}
recursivo <- list(id = c(1, 2, 3), var = c("a", "b", "c"),
                  lista = list(4:9, TRUE))
str(recursivo)
```

## Estructuras de datos

| **Dimensiones** | **Datos homogéneos**          | **Datos heterogéneos** | 
|-----------------|-------------------------------|------------------------|
|1                | Vector atómico - `vector()`   | Lista - `list()`       |
|2                | Matriz - `matrix()`           | `data.frame()`         |  
|3 o más          | Arreglo - `array()`           |                        |

## Propiedades, atributos y clases {.build}  

### Propiedades de los vectores

```{r}
## Las tres propiedades principales
typeof(logico)
length(entero)
attributes(doble)
```

## Propiedades, clases y atributos  {.build}

### Tipos, pruebas y coerción

```{r}
# Las funciones is.* y as.*  logical, integer, double, character, list
is.character(caracter)
as.integer(logico)

# Coerción por defecto:
mean(logico)
```

## Propiedades, clases y atributos {.build}

### Atributos {.build}

```{r}
str(attributes(doble))
```

```{r}
class(doble) # Se pueden modificar: class(doble) <- "myclass"
names(doble)
dim(doble)
```

## Datos faltantes y factores {.build .left-margin}

Hay una constante lógica para especificar datos faltantes. La función `is.na()` evalua si hay datos faltantes. 

```{r, eval = FALSE}
NA # logico
NA_integer_; NA_real_; NA_character_;
```

La clase factor se usa para representar variables categóricas.

```{r}
categoria <- factor(x = c("A", "B", "A", "A", "B"))
typeof(categoria)
attributes(categoria)
table(categoria)
```

## Matrices y arreglos {.build .left-margin}

```{r}
matriz <- matrix(data = runif(4), ncol = 2, nrow = 2)
arreglo <- array(data = rnorm(24), c(2, 3, 4))

dim(caracter) <- c(1, 3)
caracter

str(arreglo)
ncol(matriz); dim(arreglo)
```

## Matrices y arreglos

Algunas funciones:

Función    | Vectores      | Matrices                    | Arreglos         | 
-----------|---------------|-----------------------------|------------------|
Dimensión  | `length()`    | `ncol()` y `nrow()`         | `dim()`          |  
Nombres    | `names()`     | `rownames()` y `colnames()` | `dimnames()`     |
Concatenar | `c()`         | `cbind()` y `rbind()`       | `abind::abind()` |  

## Subselección (indexación) {.build .left-margin}

Para empezar el operador `[`

```{r}
# Nada - útil para más dimensiones
doble[]
# Entero positivo
doble[c(1, 2)]
# Entero negativo
doble[-c(1, 2)]
```

## Subselección (indexación) {.build}

```{r}
# Lógico
doble[doble > 1]
# Caracter
doble[c("a", "c", "c")]
```

El operador `[` funciona igual en listas.

## Subselección {.build}

Ahora podemos combinar las anterirores formas de subindexar en matrices y arreglos, separando por coma.

```{r}
matriz
matriz[, c(TRUE, FALSE)]
matriz[1, , drop = FALSE]
```

## Subselección {.build}

Hay dos operadores más para seleccionar. `[[` permite seleccionar sólo un valor (entero positivo o caracter), pero los extrae de las listas. `$` es un atajo para `[[` con un argumento caracter (nombres).

Además esta la función `subset()` para seleccionar de forma más limpia con condiciones lógicas.

```{r}
recursivo[[1]]
recursivo$lista[[1]][3:5]
subset(recursivo, c(FALSE, TRUE, FALSE))
```

## El ubicuo <code> data.frame </code> {.build}

Es la estructura de datos más utilizada en R. 
Es una lista de vectores atómicos (!?!).

```{r}
(df <- data.frame(x = c("a", "b", "c"), y = 1:3))

df[2, 2] # Se pueden seleccionar como en las matrices

df$y[2] # Se pueden seleccionar como en las listas
```

## El ubicuo <code> data.frame </code> {.build}

Se pueden combinar dos o más `data.frame`s con las funciones `rbind()` y `cbind()`

```{r}
df1 <- data.frame(x = c("a", "b"), y = 1:2)
df2 <- data.frame(x = c("c", "a"), y = c(6, 7))

(df <- rbind(df1, df2))
```

La forma más común de crearlo es con una variación de la función `read.table()` 

## El ubicuo <code> data.frame </code> {.build}

`subset()` con el `data.frame`

```{r}
df[df$x == "a", "y", drop = FALSE]

# Mejor así:
subset(df, subset = x == "a", select = y)
```

## Funciones {.build}

Las funciones también son objetos. Las creamos así:

```r
miFuncion <- function(arg_1, arg_2, ...){
  expresion ingeniosa o util
}
```

### En R:
- todo lo que existe es un objeto 
- todo lo que se pasa en la consola es un llamado a una función

# [Vocabulario](http://adv-r.had.co.nz/Vocabulary.html)

# Manipulación de datos con R moderno

## R moderno o el ["Hadleyverse"](https://barryrowlingson.github.io/hadleyverse/) {.build}

- `readr`, `readxl` y `haven` lectura de archivos.
- `lubridate` manejo de fechas y tiempo.
- `stringr` interface a `stringi` para manejo de caracteres.
- `dplyr` y `tidyr` manipulación y limpieza de datos.
- `ggplot2` una gramática de gráficas.

Recordemos que `install.packages()` instala paquetes y `library()` los carga en la sesión.

## Importación

```{r, echo = TRUE}
# Importar de un csv (Enfoque malo)
dat <- read.csv("./data/saber2014II.csv", sep = ";", dec=",")
# head(dat)

# Importar de un csv (Enfoque correcto)
clases <- c(rep("character", 8), rep("numeric", 8), rep("NULL", 7), "character")
datos <- read.csv("./data/saber2014II.csv", sep = ";", dec=",", colClasses = clases)
```

```{r, eval = FALSE}
library(readr)
datos <- read_csv2("./data/saber2014II.csv")

# Nuevo Paquete de Whickham para importar de Excel
library(readxl)
saber <- read_excel("./data/saber2014II.xlsx")

# Importar de SPSS con etiquetas
library(haven)
saber <- read_spss("./data/saber2014II.sav")
```

## Manipulación

### Verbos de `dplyr`

- `filter()` 
- `arrange()`
- `select()`
- `mutate()` y `transmute()`
- `summarise()`
- `group_by()`
- `*_join()`

## Manipulación {.build}

Pregunta: ¿cuántos estudiantes presentaron las pruebas Saber en el año 2014 por municipio?

```{r}
library(dplyr)
resumen_a <- datos %>%
  group_by(NOMBREMUNICIPIO) %>%
  summarize(DEPARTAMENTO = max(DEPARTAMENTO), TOTAL_EVALUADOS = sum(EVALUADOS)) %>%
  arrange(desc(TOTAL_EVALUADOS)) %>%
  mutate(ranking = row_number()) %>%
  select(ranking, DEPARTAMENTO, NOMBREMUNICIPIO, TOTAL_EVALUADOS)
```

## Manipulación

```{r}
resumen_a
```

## Manipulación {.build}

Pregunta: ¿cuál es el municipio de mejor desempeño del país en las pruebas saber?

```{r}
resumen_b <- datos %>%
  mutate(PROMGLOBAL = (PROMMATEMATICA + PROMINGLES + PROMLECTURACRITICA + 
                       PROMSOCIALESYCIUDADANAS +  PROMCIENCIASNATURALES + 
                       PROMRAZONAMIENTOCUANTITA + PROMCOMPETENCIASCIUDADAN)/7) %>%
  group_by(NOMBREMUNICIPIO) %>%
  summarize(DEPARTAMENTO = max(DEPARTAMENTO), 
            PROMGLOBALXMPIO = sum(PROMGLOBAL * EVALUADOS) / sum(EVALUADOS)) %>%
  arrange(desc(PROMGLOBALXMPIO)) %>%
  mutate(ranking = row_number()) %>%
  select(ranking, DEPARTAMENTO, NOMBREMUNICIPIO, PROMGLOBALXMPIO) 
```

## Manipulación

```{r}
resumen_b
```

## Ayuda para ir más allá {.build}

En el [CRAN](http://www.cran.r-project.org) hay una [_Vista de Tareas_](http://cran.r-project.org/web/views/) que sobrevuela paquetes, funciones y referencias para completar tareas específicas agrupadas temáticamente.

Canales: [en twitter #rstats](https://twitter.com/hashtag/rstats) y en [StackOverflow el tag R](http://stackoverflow.com/questions/tagged/r). También pueden [googlea-R](https://www.google.com.co/#q=R) R + "pregunta".  

Algunas buenas referencias:

- [Quick R](http://www.statmethods.net/)
- [Advanced R](http://adv-r.had.co.nz/) 
- [The R Inferno](http://www.burns-stat.com/pages/Tutor/R_inferno.pdf) un viaje dantesco por R
- [Springer - Use R Series](http://www.springer.com/series/6991?detailsPage=titles) R en la práctica en diferentes contextos.
- ...

## Colofón {.smaller .left-margin}

Esta presentación fue escrita en [RMarkdown](http://rmarkdown.rstudio.com/) desde RStudio y compilada por `rmarkdown` en la plantilla `ioslides` de Google gracias a [`knitr`](http://yihui.name/knitr/) y [`pandoc`](http://pandoc.org/). Publicada en la web en [GitHub](https://github.com/bogota-r/intro) gracias a [GitHub Pages](https://pages.github.com/).

La presentación fue preparada por por Daniel Moreno, Adriana Clavijo y Jose Zea para el [Grupo de Usuarios de R de Bogotá](http://www.meetup.com/Bogota-R-Users-Group/) y el contenido original esta bajo la licensia [CC-BY 4.0](http://creativecommons.org/licenses/by/4.0/).


[![CC BY](http://i.creativecommons.org/l/by/4.0/88x31.png)](http://creativecommons.org/licenses/by/4.0/ "CC-BY-4.0")