Seminario de Instrumentos Computacionales

class: center, middle, inverse, title-slide

.title[
# Seminario de Instrumentos Computacionales
]
.subtitle[
## R - Clase 1
]
.author[
### Cristian Bonavida - UNLP
]

---

---

# ¿Qué es R?

R es un **lenguaje** y es un **software** que permite el análisis estadístico y gráfico.

-   **Lenguaje** porque tiene su propia sintaxis desde la cual escribir las sentencias y comandos

-   Es un **software** porque es al mismo tiempo un programa o entorno integrado con múltiples funcionalidades

---

# ¿Por qué aprender R?

-   R es un programa **abierto y gratuito**. Es decir de acceso libre y que se expande con contribuciones de la comunidad de usuarios (paquetes)

-   Está especialmente enfocado en tareas de **cómputo y análisis estadístico**

-   Es tremendamente **eficiente** para el procesamiento de grandes volúmenes de datos.

-   Es un programa muy **versátil** que permite utilizar la misma herramienta para una gran variedad de fines y aplicaciones

---

# ¿En el medio entre Stata y Python?

-**Python** es lo que se conoce como ["general-purpose programming language"](https://zims-en.kiwix.campusafrica.gos.orange.com/wikipedia_en_all_nopic/A/General-purpose_programming_language). Con Python podemos programar prácticamente lo que sea, correr cualquier modelo de machine learning, hacer back-end de páginas web, etc

-**R** es un lenguaje del tipo ["domain-specific language (DSL)"](https://en.wikipedia.org/wiki/Domain-specific_language) porque sus funciones están pensados para un área de uso o dominio específico. En este caso para el análisis estadístico y gráfico de manera eficiente y sucinta. R, al igual que Python se expanden muy rápidamente en sus funciones y usos y están pensados para tareas que implican un procesamiento computacional intensivo.

-**Stata** por su parte es un programa con funcionalidades muchos más especificas y acotadas. Su uso está orientado a la econometría (especialmente en el campo de la economía) y sus aplicaciones son menos versátiles. "You have one job...". Además se expande de manera más lenta en sus aplicaciones y extensiones.

---

## Las ganancias de R

Además de ser un programa con múltiples aplicaciones, R es ampliamente eficiente en el procesamiento de datos

<div class="figure" style="text-align: center">
<img src="inputs/Clase1/performance.png" alt="Fuente:https://github.com/matthieugomez/benchmark-stata-r" width="53%" height="33%" />
<p class="caption">Fuente:https://github.com/matthieugomez/benchmark-stata-r</p>
</div>

---

## ¿Aun más eficiente?

Como veremos luego los paquetes permiten expandir R, e incluso existen paquetes que vuelven al procesamiento de datos mucho mas eficiente respecto a la performance de base

<div class="figure" style="text-align: center">
<img src="inputs/Clase1/dt_dplyr.jpg" alt="Fuente:https://matthewdharris.com/2016/11/07/data-table-v-dplyr-execution-time/" width="70%" height="50%" />
<p class="caption">Fuente:https://matthewdharris.com/2016/11/07/data-table-v-dplyr-execution-time/</p>
</div>

---

## ¿Pará qué podemos usar R?

Aparte del uso mas convencional como herramienta de procesamiento estadístico, R nos puede servir para

- Generar múltilpes visualizaciones y personalización de gráficos
- Web Scraping
- Automatizar reportes
- Implementar análisis con algoritmos de Machine Learning
- Generar tableros o aplicaciones (shiny por ejemplo)
- Hacer presentaciones (o slides como estas!)
- Subir y publicar contenido con R-markdown

---

## Fijemos expectativas...

El **objetivo** de este curso es *introducirnos* al lenguaje y al uso de R y explorar los usos más comunes y útiles **para el análisis de datos**.

No es un curso exhaustivo que abarque todas las múltiples aplicaciones y posibilidades de emplear R.

Vamos a tratar de hablar "todos el mismo idioma" es decir trabajar sobre los fundamentos, y eso les permitirá luego ir expandiendo su bagaje de R hacia los usos que quieran o necesiten darle.

La estrategia entonces será **cubrir lo principal** y trataremos de **motivar** y dar un pantallazo de los temas más avanzados o específicos como herramienta inicial que permita luego profundizar.

AHORA SÍ... EMPECEMOS!

---

## Interface

¿Con qué nos vamos a encontrar?

---

## Interface

Básicamente al trabajar  en RStudio, estaremos interacturando con estos 4 paneles

Veamos para qué utilizamos cada uno:

- **Script**: Es nuestro cuaderno, nuestro block de notas. Allí **escribimos** las líneas de códigos de nuestro proyecto y una vez que lo guardemos podremos volver a retomar desde donde dejamos. Desde el script podremos correr estos códigos directamente.

- Para comenzar un script vamos a `File` --> `New File` --> `R Script`
  - Para abrir un script guardado vamos a `File` --> `Open File`
  
--

- **Consola**: Es la salida de R, el lugar donde visualizamos el **output**, lo que ocurre al correr el código. A diferencia del script este ouptut se limpia cada vez que abrimos RStudio. Cuando el código corre bien, veremos letras azules en la consola y cuando hay un error o una advertencia, en color rojo.

---

## Interface

Básicamente al trabajar en RStudio, estaremos interacturando con estos 4 paneles

Veamos para qué utilizamos cada uno:

- **Environment**: Este es el entorno de R que contiene todos los elementos que hemos generado y creado: valores, bases de datos, objetos, etc. Es el "lugar donde viven" estos elementos, como una especie de **alacena** que se va llenando a medida que vamos corriendo códigos que definen y modifican elementos. Esa alacena se vacía con cada nueva sesión de RStudio.
  
--

- **Panel de Visualización**: nos permite interactuar de forma fácil con los subdirectorios (pestaña *Files*), visualizar los gráficos que creamos (pestaña *Plots*), cargar y buscar paquetes manualmente (pestaña *Packages*), acceder al help de cada función (pestaña *Help*) y visualizar contenido html (pestaña *Viewer*). Es una especie de **atajo** multiuso.

---

## Mi primer código

Parece que todo la acción es consecuencia de haber corrido un código.
--
 Y es así

¿Cómo lo hacemos?

Para correr un comando o sentencia podemos hacerlo desde el script de distintas maneras:

- Parándonos en la linea anterior al código y apretando `Ctrl` + `Enter`.
--
De esta forma iremos corriendo de a una línea a la vez

- Seleccionando una o varías líneas de código y apretando `Ctrl` + `Enter` o desde el botón `"Run"` arriba a la derecha. 
--
De esta forma podemos correr una o varias lineas a la vez

También es posible escribir el código en la consola y al apretar `Enter` este se ejecuta

---

## Mi primer código

Parece que todo la acción es consecuencia de haber corrido un código. Y es así

¿Qué pasa cuando corremos un código?

-   En la **consola** veremos el código en azul si corrió bien y debajo el output o salida como consecuencia de la sentencia

-   Si el código implica definir un objeto (ya veremos que significa esto) ese objeto aparecerá ahora en nuestro **entorno** de trabajo

-   Si el código implica generar un gráfico lo veremos en ese caso en el **panel** de navegación

-   En el **script** no pasará nada, ya que allí solo escribimos y llamamos al código al momento de correrlo

---

## Mi primer código

---

## Mi primer código

---

## Mi primer código

Ahora pruebenlo por ustedes mismos. Copien y peguen el código, llévenlo a su sesión de RStudio y corran estas líneas

```r
print("Este es mi primer código")

valor_1 <- 5

valor_2 <- 5*5
```

Bien hecho!

Ahora sí ya estamos listos para meternos de lleno en los conceptos principales de R e ir, en simultaneo, corriendo y probando cada aplicación que vayamos viendo. 
--
Esta será la dinámica propuesta para el aprendizaje.

Comenzaremos por los elementos fundamentales, para construir desde lo más básico de manera aditiva y progresiva.

---

## Elementos Fundamentales

-   Valores

-   Vectores

-   Funciones (comandos)

-   Data Frames (base de datos)

---

## Elementos Fundamentales

-   **Valores**

-   Vectores

-   Funciones (comandos)

-   Data Frames (base de datos)

---

## Valores

Es el elemento más básico que existe en el entorno de R

-   `5` es un valor numérico

-   `5*6` es también un valor numérico

-   `"dos"` es un valor character

-   `"dos días"` es también un valor character

-   `FALSE` es un valor booleano o lógico

---

## Elementos Fundamentales

-   Valores

-   **Vectores**

-   Funciones (comandos)

-   Data Frames (base de datos)

---

## Vectores

Los vectores son una colección de valores

Para agrupar esos valores utilizamos el comando `c()`

Estos también pueden ser de distinto tipo:

```r
c(5, 5*6)

c("dos", "dos días")

c(5*6, "días")
```

---

## Objetos

Notar que ninguno de los valores ni vectores anteriores fueron almacenados en un objeto. Si quisiera llamarlos ¿cómo haría?

**Tengo primero que definirlo!** Especificando 3 inputs:
-   nombre del objeto
-   utilizar el operador asignación `<-` (pensarlo como un `=`)
-   contenido

```r

objeto_1 <- 5
objeto_1
## [1] 5

objeto_2 <- 5 * 6
objeto_2
## [1] 30

objeto_3 <- objeto_1 + objeto_2
objeto_3
## [1] 35
```

---

## Objetos

Mismo para vectores

Definir un objeto me permite luego llamarlo para distintas operaciones (lo que se conoce como vectorización)

```r

vector_0 <- c(1, 3, 4)
vector_0
## [1] 1 3 4

vector_1 <- vector_0 + 12
vector_1
## [1] 13 15 16

vector_2 <- vector_0 + (12:14)
vector_2
## [1] 13 16 18
```

---

## Objetos

Otros ejemplos con vectores del tipo character

```r
ARG_1 <- "muchaaaaaachos,"
ARG_2 <- "ahora nos volvimos a ilusionar"

ARG <- paste(ARG_1, ARG_2)
print(ARG)
```

```
## [1] "muchaaaaaachos, ahora nos volvimos a ilusionar"
```

---

## Tipos de datos

Aparte de los numéricos y character. ¿Qué otro tipo de datos existen?

---

## Tipos de datos

¿Cómo podemos conocer qué tipos de datos son? Podemos emplear el comando `class()` de forma genérica

```r

class(5)
## [1] "numeric"

class("ARGENTINA")
## [1] "character"

class(TRUE) 
## [1] "logical"
```

---

## Tipos de datos

De la misma manera, podemos testear específicamente cada tipo de dato con el conjunto de funciones `is()`

---

## Tipos de datos

```r
is.integer(5)
is.integer("ARGENTINA")
is.character("ARGENTINA")
```

```
## [1] FALSE
## [1] FALSE
## [1] TRUE
```

---

## Elementos Fundamentales

-   Valores
-   Vectores
-   **Funciones** (comandos)
-   Data Frames (base de datos)

---

## Funciones

Ya sabemos para que sirve `is.interger()`, `class()`, también usamos un ejemplo con `paste()`

Ahora, estos elementos no son ni valores, ni vectores. ¿Qué son?

---

## Funciones

Las funciones son comandos, son expresiones que encierran una orden predeterminada.

Al invocar una función le estaremos diciendo a R que realice una tarea particular.

Para ejecutar una función R necesita de dos inputs:

- Nombre de la función
- Argumento

```r
class(5)   # "class" es el nombre de la función
           # 5 es el argumento
```

```
## [1] "numeric"
```

---

## Funciones

Existen interminables tipos de funciones. De las mas simples a las mas complejas. Sea cual fuera la función, siempre, los argumentos están predefinidos. Los argumentos pueden ser

- Opcionales
 - Requeridos
  
Si pasamos una función y nos falta algún argumento requerido, R no podrá completar la tarea

```r
strsplit(x = "CAMPEONES DEL MUNDO - 2022")
```

```
## Error in strsplit(x = "CAMPEONES DEL MUNDO -
2022"): el argumento "split" está ausente, sin
valor por omisión
```

---

## Funciones

Para dividir el texto, la función requiere un argumento **obligatorio** que indique el patrón que separa en dos la expresión

```r
strsplit(x="CAMPEONES DEL MUNDO - 2022", split="-")
```

```
## [[1]]
## [1] "CAMPEONES DEL MUNDO " " 2022"
```

---

class: title-slide, top, left, inverse
background-image: url("inputs/Clase1/messi_copa.jpg")
background-size: cover

## Funciones

Y el siguiente comando funcionaría?

Aparte del fondo, qué otra diferencia notan respecto de la slide anterior...

```r
strsplit("CAMPEONES DEL MUNDO - 2022", "-")
```

```
## [[1]]
## [1] "CAMPEONES DEL MUNDO " " 2022"
```

Sí, porque los argumentos pueden indicarse en orden, ahorrándonos tener que llamarlos explícitamente. R entiende solo a qué no referimos

---

## Funciones

Los argumentos tienen valores por default, es decir por omisión. La función esta setteada de manera que, si no indico lo contrario, el argumento tomará una valor por default.

```r
valores <- c(5, 25, 65, NA, 110, 220)
sum(valores)
sum(valores, na.rm=TRUE)
```

```
## [1] NA
## [1] 425
```

La función `sum()` incluye los valores `NA` en la suma, ya que por default el argumento `na.rm` es `FALSE`. Por eso el resultado arrojado será también `NA`. Para cambiar ese comportamiento tengo que explicitar el argumento como `TRUE`

---

## Funciones

Otro ejemplo

```r
pi <- 3.141592653
pi_inter <- round(pi) 
pi_inter
```

```
## [1] 3
```

En este caso, no explicitamos el argumento `digits()` en la función, el cual indica cuántos decimales incluir. El valor por omisión es 0

```r
pi_decim <- round(pi, digits = 2) 
pi_decim 
```

```
## [1] 3.14
```

---

## Funciones

Cómo hacemos para saber cuales son los argumentos de cada función y cuáles son sus valores por default.

Al igual que en stata, tenemos un comando como el help.

```r
?sum()
```

![Documentación](inputs/Clase1/help_output.PNG)

---

## Funciones

Además de la documentación completa, también podemos  darle una mirada rápida a la función desde la consola directamente. Esto resulta muy practica cuando estamos escribiendo el código y lo que necesitamos es "refrescar la memoria"

![Documentación](inputs/Clase1/guide_console.PNG)

---

## Funciones

Como veremos mas adelante, en R es sencillo y de gran ayuda crear nuestras propias funciones, según lo que necesitemos hacer.

Por suerte, existe una enorme comunidad de usuarios, quienes ya desarrollaron un infinidad de funciones las cuales podemos aprovechar.

---

## Paquetes

Cuando instalamos R, el programa ya trae una serie de funciones `base`. Una de las grandes ventajas de R, es que puede expandirse en sus usos y aplicaciones a partir de otros paquetes.

Los paquetes no son otra cosa que un *wrap* o grupo de funciones, que tienen una aplicación común o que sirven para realizar un conjunto de tareas similares.

Pueden pensarlas como funciones agrupadas por temática de uso

Por ejemplo, el paquete `"stringr"` incluye funciones para trabajar con *strings*

---

## Paquetes

Para poder usar un paquete hay que hacer dos cosas.

- Instalarlo
- Cargarlo

```r
install.packages("stringr")   #instalo
library(stringr)              #cargo
```

Listo!

---

## Paquetes

El cuidado que debemos tener es que, la haber tantos paquetes, el mismo nombre o similar puede referir a funciones de paquetes distintos.

Nuevamente, la información desde la consola nos ayuda a saber cuál es cuál y a elegir la función deseada

![Una función similar, pero distintos paquetes](inputs/Clase1/guide_packages.PNG)

---

## Paquetes

La mejor forma de asegurarnos que estamos usando la función del paquete que queremos, es llamar primero al paquete y luego elegir dentro de él, la función buscada.

Para eso escribimos el nombre del paquete seguido de "::"

```r
stringr::str_split()
```

---

## Elementos Fundamentales

-   Valores
-   Vectores
-   Funciones 
-   **Data Frames** (bases de datos)

---

## Data Frames

Un data frame es el elemento más típico para trabajar con datos.

Es una estructura de datos **tabular**, es decir ordenados en **columnas** (variables) y **filas** (observaciones).

Un dataframe es un conjunto de vectores, los cuales pueden ser de **distinto tipo**, pero que deben ser de de la **misma longitud**

---

## Data Frames

Voy a crear un objeto llamado "df" a partir de vectores con el comando `data.frame()`

```r
sede <- c("Alemania", "Sudáfrica", "Brasil", "Rusia", "Qatar")
año <- seq(2006, 2022, 4)
campeon <- c("Italia", "España", "Alemania", "Francia", "Argentina")
publico <- c(69000, 84490, 74738, 78000, 88966)
penales <- c(TRUE, FALSE, FALSE, FALSE, TRUE)

df <- data.frame(sede, año, campeon, publico, penales)
```

---

## Data Frames

|sede      |  año|campeon   | publico|penales |
|:---------|----:|:---------|-------:|:-------|
|Alemania  | 2006|Italia    |   69000|TRUE    |
|Sudáfrica | 2010|España    |   84490|FALSE   |
|Brasil    | 2014|Alemania  |   74738|FALSE   |
|Rusia     | 2018|Francia   |   78000|FALSE   |
|Qatar     | 2022|Argentina |   88966|TRUE    |

---

## Data Frames

Inspeccionando el dataframe

- Cual es la dimensión de este dataframe?

--
- Cuales son los nombres de las variables?

--
- Cuantas filas tiene?

--
- De qué clase es?

```r

dim(df)
## [1] 5 5
names(df)
## [1] "sede"    "año"     "campeon" "publico" "penales"
nrow(df)
## [1] 5
class(df)
## [1] "data.frame"
```

---

## Subconjuntos

Algo MUY importante, es saber cómo **navegar por un dataframe o por un vector**

Esto me va a permitir generar subconjuntos de datos, definir nuevos elementos, operar sobre ellos, etc

Por ejemplo, ¿cómo hago para **llamar a un elemento** de un vector?

Debo indicar el *orden* del elemento

```r

actual <- campeon[5]
actual
## [1] "Argentina"
```

---

## Subconjuntos

Obviamente, puedo llamar a mas de un elemento a la vez.

Por ejemplo si quisiera saber cuál son **los últimos dos** campeones

```r

ultimos_2 <- campeon[4:5]
ultimos_2
## [1] "Francia"   "Argentina"
```

---

## Subconjuntos

¿Cómo hago para **quitar** el elemento del medio?

```r

out_ger <- campeon[-3]
out_ger
## [1] "Italia"    "España"    "Francia"   "Argentina"
```

Supongamos que la cantidad de público en Rusia fue de 88000 y no 78000. Se les ocurre cómo hago para **modificar el valor**?

```r

publico[4] <- 88000
publico
## [1] 69000 84490 74738 88000 88966
```

---

## Subconjuntos

¿Cómo hago para sumar la cantidad de espectadores en las dos ultimas ediciones?

```r

suma_pub_v1 <- publico[4] + publico[5]
suma_pub_v1
## [1] 176966

suma_pub_v2 <- sum(publico[4], publico[5])
suma_pub_v2
## [1] 176966

suma_pub_v3 <- sum(publico[4:5])
suma_pub_v3
## [1] 176966

suma_pub_v1 == suma_pub_v2
## [1] TRUE
suma_pub_v2 == suma_pub_v3
## [1] TRUE
```

---

## Subconjuntos

Si quisiera extraer el elemento 1 y 5 del vector... esto estaría bien?

```r
prueba <- campeon[1,5]
```

```
## Error in campeon[1, 5]: número incorreto de
dimensiones
```

Porque los vectores son elementos unidimensionales y la coma le indica a R, que estamos buscando elementos en dos dimensiones. En este caso **1 refiere a la fila y 5 a la columna**

`df[fila, columna]`

---

## Subconjuntos

Para definir un nuevo vector con el elemento 1 y 5 del vector de campeones tengo que usar el constructor que ya vimos: `c()`

```r
prueba <- c(campeon[1], campeon[5])
prueba
```

```
## [1] "Italia"    "Argentina"
```

---

## Subconjuntos

Con esto en mente: `df[fila, columna]`

Ahora veamos cómo acceder a elementos del data frame

Quiero traer **TODAS LAS OBSERVACIONES** de la fila "penales", que es la última fila

```r

prueba1 <- df[,5]
prueba1
## [1]  TRUE FALSE FALSE FALSE  TRUE

prueba2 <- df[,"penales"]
prueba2
## [1]  TRUE FALSE FALSE FALSE  TRUE
```

Si en fila no indico nada, R entiende que quiero traer todas las filas de esa columna

---

## Subconjuntos

Ahora traigamos **la primer fila** de la misma columna "penales"

```r

prueba1 <- df[1,5]
prueba1
## [1] TRUE

prueba2 <- df[1,"penales"]
prueba2
## [1] TRUE
```

---

## Subconjuntos

Ahora solo la **primer fila**, pero con **todas las columnas**

```r
prueba <- df[1,]
prueba
```

```
##       sede  año campeon publico penales
## 1 Alemania 2006  Italia   69000    TRUE
```

---

## Repaso

---

## Operador $

Por qué es necesario indicar siempre df?

Porque a diferencia de stata, **podemos tener el entorno de trabajo múltiples data frames definidos** y por tanto para llamar al elemento primero debo llamar a dataframe:

Existe otra manera, muy usada en R de hacer esto: el símbolo `$`

---

## Operador $

Partimos desde el dataframe y luego indicamos la columna:

`data.frame()` >> `columna`

O lo que es lo mismo:

`data.frame()` >> `vector`

```r
df$penales
```

```
## [1]  TRUE FALSE FALSE FALSE  TRUE
```

---

## Operador $

De la misma manera que hacíamos antes

el operador `$` nos permite traer un elemento particular

---

## Operador $

Partimos desde el dataframe y podemos llegar hasta una observación puntual:

`data.frame()` >> `columna` >> `observación`

O lo que es lo mismo:

`data.frame()` >> `vector` >> `valor`

```r
df$penales[1]
```

```
## [1] TRUE
```

---

## Filtrar observaciones

Muchas veces lo que queremos hacer no es traer una observación puntual, sino todas aquellas que cumplen con una condición. Es decir que queremos *filtrar* nuestros datos

La regla es la de siempre: `df[fila, columna]`

Vimos que esto nos traía todas las filas

```r
df[,]
```

```
##        sede  año   campeon publico penales
## 1  Alemania 2006    Italia   69000    TRUE
## 2 Sudáfrica 2010    España   84490   FALSE
## 3    Brasil 2014  Alemania   74738   FALSE
## 4     Rusia 2018   Francia   78000   FALSE
## 5     Qatar 2022 Argentina   88966    TRUE
```

--
Porque no especificábamos nada antes de la coma.

---

## Filtrar observaciones

`df[fila, columna]`

En la posición de las filas es donde ahora debemos pasarle la condición. Para ello debo indicar:

- sobre qué variable voy a buscar que se den determinados valores
- cual es, o cuáles son, esos valores

Por ejemplo, si quiero quedarme con todos los mundiales donde la final se definió por penales:

```r
df[df$penales==TRUE,]
```

```
##       sede  año   campeon publico penales
## 1 Alemania 2006    Italia   69000    TRUE
## 5    Qatar 2022 Argentina   88966    TRUE
```

---

## Filtrar observaciones

Si queremos las observaciones para los mundiales donde el público fue mayor a 75 mil espectadores

```r
df[df$publico > 75000,]
```

```
##        sede  año   campeon publico penales
## 2 Sudáfrica 2010    España   84490   FALSE
## 4     Rusia 2018   Francia   78000   FALSE
## 5     Qatar 2022 Argentina   88966    TRUE
```

---

## Filtrar observaciones

Notar que en los anteriores casos estoy llamando a las filas que cumplen la condición y a *todas la columnas del dataframe*

Si ahora quisiera saber cuál fue la sede del Mundial cuando el campeón fue España, ¿Cómo harían?

Piensen de nuevo en `df[fila, columna]`

```r
df[df$campeon=="España", "sede"]
```

```
## [1] "Sudáfrica"
```
--

La orden:

*Del dataframe `df` quedate con las filas donde el valor de la columna `campeón` sean iguales a "España" y para esas observaciones traeme el valor que toma la columna `sede`*

---

## Filtrar observaciones

¿Se les ocurre otra forma?

```r
df$sede[df$campeon=="España"]
```

```
## [1] "Sudáfrica"
```
--

La orden:

*Del dataframe `df` traer la columna `sede`, cuando los valores de la columna `campeón` sean iguales a `"España"`*