>Reiniciar R

```{r, warining = FALSE}
library(tidyverse)
library(openxlsx)
library(ggthemes)
```


# Loops
Un __loop__ es una estructura de código que nos permite aplicar iterativamente un mismo conjunto de comandos, variando algún elemento sobre el cual se trabajará. Por ejemplo:

```{r,warning=FALSE}
for(i in 1:10){
   print(i^2)
}
```

Esto se lee como : "Recorre cada uno de los valores (i) del vector numérico 1 a 10, y para cada uno de ellos imprimí el cuadrado (i^2)".                  
Uno puede especificar la palabra que desee que tomé cada uno de los valores que debe tomar. En el ejemplo anterior fue **i**, pero bien podría ser la "**Valores**"  

```{r}
for(Valores in 1:10){
   print(Valores^2)
  
}
```

A su vez, los loops pueden iterar sobre los distintos valores de una variable en un **Dataframe**. 
A continuación realizaremos un ejemplo iterando sobre la variable *REGION* en la base de EPH, para replicar para cada región el gráfico boxplot visto en la clase 3, . Previamente unimos la base con el diccionario de Nombres de Regiones y Códigos.   

```{r,message=FALSE,warning=FALSE}

Individual_t117 <- read.table("../Fuentes/usu_individual_t117.txt",
                              sep=";", dec=",", header = TRUE, fill = TRUE)
Regiones <- read.xlsx("../Fuentes/Regiones.xlsx")
Aglomerados <- read.xlsx("../Fuentes/Aglomerados EPH.xlsx")

ggdata <- Individual_t117 %>% 
  left_join(Regiones) %>% 
  filter(P21>0, !is.na(NIVEL_ED)) %>% 
  mutate(NIVEL_ED = as.factor(NIVEL_ED),
         CH04     = as.factor(CH04))
```
Para iterar sobre la variable región, no necesitamos recorrer todos los valores de la misma, sino por los **valores únicos**. Es decir, que vamos a querer realizar un loop que realizará un mismo procedimiento 6 veces. Para ello, utilizaremos la función **unique** que nos permite obtener un vector con los únicos valores que toma determinada variable.

```{r}
unique(ggdata$Region)
```

```{r, warning=FALSE, message=FALSE}
pdf(file = "../Resultados/Graficos_Region.PDF")
for(variable_itera in unique(ggdata$Region)){
print(variable_itera)# No es necesario, permite ver por que Región estoy trabajando
  
Base_Reg <- ggdata %>% # Aquí filtro la base cuando Region toma el valor de "variable_itera"
  filter(Region == variable_itera) 

Graf_Reg <- ggplot(Base_Reg, 
                   aes(x= NIVEL_ED, y = P21, group = NIVEL_ED, fill = NIVEL_ED )) +
  geom_boxplot()+
  scale_y_continuous(limits = c(0, 40000))+
  labs(title = paste0("Region ", variable_itera))+
  facet_wrap(~ CH04, labeller = "label_both")

print(Graf_Reg)
    }
dev.off()
```

# Estructuras Condicionales

Las __estructuras condiconales__ nos permites ejecutar determinado código, o determinada función sobre una variable, acorde al cumplimiento o no de determinada condición lógica.     
## if
La función ```if()```nos permite diseñar un segmento de código que solo sera ejecutado en caso de que se cumpla determinada condición. Su funcionamiento es el siguiente:     
```if(condicion){codigo a ejecutar si se cumple la condición}```
```{r,warning=FALSE}
if( 2+2 == 4){
  print("Menos Mal")
}
```

```{r,warning=FALSE}
if( 2+2 == 148.24){
  print("R, la estas pifiando")
}

```
## ifelse
La función ```if_else()``` sirve para crear o modificar dicotómicamente un objeto/variable/vector a partir del cumplimiento de una o más condiciones lógicas.  
Su funcionamiento es el siguiente:      
```if_else(condicion,función a aplicar si se cumple la condición,función a aplicar si no se cumple la condición)```

```{r}


resultado <- if_else(2+2==4, true = "Joya",false = "Error") #Versión dplyr

ABC_123 <- data.frame(Letras = LETTERS[1:20],Num = 1:20)
ABC_123 %>% 
  mutate(Mayor_o_Menor = ifelse(Num<=5,"Menor o igual que 5","Mayor que 5")) #Versión base
```
# Funciones del Usuario

La creación de __funciones__ propias nos permite automatizar todas aquellas partes del código que se repiten mucho. Una vez diseñadas, funcionan igual que cualquier comando. La facilidad para crear las funciones es en buena medida la explicación de que haya tantas contribuciones de usuarios a la expansión del lenguaje.

Por ejemplo, podríamos diseñar una función que agregue una flecha a dos objetos de texto

```{r}
funcion_prueba <- function(parametro1,parametro2) {
  paste(parametro1, parametro2, sep = " <--> ")
}

funcion_prueba(parametro1 = "A ver", parametro2 = "Que pasa")

```

También podemos asignar un valor por default para los parametros en caso de que el usuario no defina su valor al utilizar la función.

```{r}
Otra_funcion_prueba <- function(parametro1 ,parametro2 = "Te colgaste en ingresar algo") {
  paste(parametro1, parametro2, sep = " <--> ")
  
}
Otra_funcion_prueba(parametro1 = "Valor 1 ")

```

Las funciones que creamos nosotros permanecen en el ambiente de R temporariamente. Cuando removemos los objetos del ambiente, la función deja de existir. Por ende, debemos incorporarla en cada uno de los scripts en la cual la necesitemos. Una buena práctica, es incorporar nuestras funciones útiles al comienzo de cada script junto a la carga de las librerías.                         

Vale mencionar que __lo que ocurre en una función, queda en la función__ excepto que explícitamente pidamos que devuelva el resultado, con el comando `print()`. 

Las funciones siempre devuelven el último objeto que se crea en ellas, o si explicitamente se utiliza el comando `return()`

# Lubridate    

El paquete lubridate está pensado para trabajar con los datos tipo fecha(date) o fecha-hora(datetime) para cambiarles el formato, realizar operaciones y extraer información

## Cambio de formato

Existe una gran cantidad de funciones para realizar esto. La idea general es poder llevar los objetos datetime a un formato común compuesto de los elementos: año, mes, día, hora, minuto y segundo (también se puede setear el huso horario)

```{r, warning=FALSE, message=FALSE}
library(lubridate)
fecha  <- "04/12/92 17:35:16"
fecha
```

Con la función dmy_hms podemos convertir este string a una fecha: estamos indicando que el formato de la fecha es día(d), mes(m), año(y), hora(h), minuto(m) y segundo(s)
```{r}
fecha  <- dmy_hms(fecha)
fecha
```
Muchas funciones de lubridate operan con esta misma lógica

Otra función para realizar un cambio de formato es *parse_date_time*. Permite construir objetos datetime a partir de datos más complejos, como por ejemplo cuando aparece el nombre del mes y el año.

En el parámetro *x* pasamos el dato de la fecha y en el parámetro *orders* especificamos el orden en el cual se encuentra la información de la fecha

```{r}
fecha2  <- "Dec-92"
fecha2 <- parse_date_time(fecha2, orders = 'my')
fecha2
```


## Extracción de información

Existen muchas funciones muy sencillas para extraer información de un objeto datetime. Algunas son

```{r}
year(fecha) # Obtener el año
month(fecha) #Obtener el mes
day(fecha) # Obtener el día
wday(fecha, label = TRUE) #Obtener el nombre del día
hour(fecha) #Obtener la hora
```

## Operaciones

Podemos sumar o restarle cualquier período de tiempo a un objeto datetime

```{r}
# Sumo dos días 
fecha + days(2)
# Resto 1 semana y dos horas
fecha - (weeks(1) + hours(2))
```


# MAP^[basado en https://jennybc.github.io/purrr-tutorial/ls03_map-function-syntax.html]

La función __map__ toma un input, una función para aplicar, y alguna otra cosa (por ejemplo parametros que necesite la función)

- map(.x, .f, ...)
- map(VECTOR_O_LIST_INPUT, FUNCTION_A_APLICAR, OTROS_OPCIONALES)


Usamos __map2__ cuando tenemos que pasar dos input, que se aplican sobre una función:

- map2(.x, .y, .f, ...)
- map2(INPUT_UNO, INPUT_DOS, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Si tenemos más de dos...

- pmap(.l, .f, ...)
- pmap(VECTOR_O_LIST_INPUT, FUNCTION_A_APLICAR, OTROS_OPCIONALES)


Por ejemplo. Si queremos utilizar la función prueba sobre los datos del dataframe ABC_123




```{r}
ABC_123
funcion_prueba
```

Si el resultado que queremos es que junte cada fila, necesitamos pasarle dos parámetros: utilizamos `map2()`


```{r}
resultado <- map2(ABC_123$Letras,ABC_123$Num,funcion_prueba)
resultado[1:3]
```

La salida de los `map()` es una __lista__, no un vector, por lo que si lo metemos dentro de un dataframe se vería así:

```{r}
ABC_123 %>% 
  mutate(resultado= map2(Letras,Num,funcion_prueba))

```

al ponerlo dentro del dataframe desarma la lista y guarda cada elemento por separado.
La magia de eso es que podemos __guardar cualquier cosa en el dataframe__ no sólo valores, sino también listas, funciones, dataframes, etc.

Si queremos recuperar los valores originales en este caso podemos usar `unlist()`


```{r}
ABC_123 %>% 
  mutate(resultado= unlist(map2(Letras,Num,funcion_prueba)))

```


Si lo que queríamos era que la función nos haga todas las combinaciones de letras y número, entonces lo que necesitamos es pasarle el segúndo parametro como algo _fijo_, poniendolo después de la función. 

```{r}
map(ABC_123$Letras,funcion_prueba,ABC_123$Num)[1:2]
```

En este caso, el map itera sobre cada elemento de `letras`, y para cada elemento _i_ hace 
`funcion_prueba(i,ABC$Num)` y guarda el resultado en la lista

si lo queremos meter en el dataframe

```{r}
ABC_123 %>% 
  mutate(resultado= map(Letras,funcion_prueba,Num))
```

Ahora cada fila tiene un vector de 20 elementos guardado en la columna resultado


# Lectura y escritura de archivos intermedia
R tiene formatos de archivos propios:

- Rdata
- RDS

## RData
```{r}
x <- 1:15
y <- list(a = 1, b = TRUE, c = "oops")

#Para guardar
save(x, y, file = "xy.RData")

#Para leer
load('xy.RData')
```

Los archivos de tipo __RData__ permiten grabar una _imagen_ de todos los objetos R que querramos.

## RDS

```{r}
x
saveRDS(x, "x.RDS")

Z <- readRDS("x.RDS")
Z
```

Los archivos de tipo __RDS__ no guardan el nombre del objeto, por lo que podemos nombrarlos cuando los cargamos (aconsejable)

## SPSS, STATA, SAS

A su vez, también R facilmente permite la comunicación con otros softwares estadísticos, o programas destinados al manejo de bases de datos. La librería _haven_ tiene funciones que permiten leer archivos que provienen de otros programas como __SPSS__, __STATA__ y __SAS__, entre otros. Los comandos son:

- read_spss()
- read_dta()
- read_sas()

## Encoding
Tanto a la hora de leer y escribir archivos, como al trabajar un mismo script desde distintas computadoras, debemos ser cuidadosos con el _encoding_ seteado. El _encoding_ es el sistema mediante el cual el sistema interpreta los caracteres del lenguaje natural. Hay muchos _encodings_ diferentes, que interpretan distinto algunos caracteres, como tildes y signos de puntuación.     
Por ende, si el _encoding_ seteado no es el mismo que el de nuestro script/tabla pueden generarse errores. En medida de lo posible, al escribir nuestros scripts es recomendable evitar estos caracteres. 

R tiene por default el encoding __"ISO-8859-1"__, sin embargo el más habitual en América Latina es __"UTF-8"__. 

- **Lectura de archivos** : Aglunas de las funciones del tipo __read_table__, __read.xlsx__ permiten establecer como uno de sus parametros el _encoding_ deseado 
- **Encoding utilizado para abrir un script**:File -> Reopen with Encoding
- **Encoding default con el que se guardan nuestros Scripts**: Tools -> Global Options -> Code -> Saving
# Organización scripts

Por último, es aconsejable mantener en todos los script una misma estructura del tipo:

1. Cargar librerías
2. Definir funciones
3. Levantar archivos     
... procesamiento ....     
n. grabar resultados

También es útil organizar las partes del script en capítulos. Para eso   


```### escribimos el título del capitulo encerrado entre tres o más numerales ###```


# Ayudas

Hay muchas ayudas, propias del programa, o de usuarios, que pueden ser de ayuda.

- En el programa, para consultar los parámetros de una función, le escribe ```?funcion()```

- [Rstudio](https://www.rstudio.com/resources/cheatsheets/) tiene unos machetes muy útiles

- [Rdocumentation](https://www.rdocumentation.org/)

- [stack overflow](https://stackoverflow.com/questions/tagged/r) conviene llegar desde google

La _clave_ es aprender la terminología para googlear en ingles las dudas, y prestar atención a que las respuestas sean actuales (R es un lenguaje _vivo_)

# Ejercicios para practicar
- Crear mediante un **loop** un gráfico de barras por región, donde se compare el ingreso de la ocupación principal promedio de varones y mujeres en el 1er trimestre de 2017.           
- Crear una **función** llamada _HolaMundo_ que imprima el texto "Hola mundo"
- Crear una **función** que devuelva la sumatoria de los números enteros comprendidos entre 1 y un parámetro _x_ a definir

- Levantar la base Individual del 1er trimestre de 2017, de la EPH
- Guardar la base Individual del 1er trimestre de 2017 como un archivo de extensión .RDS
- Volver a levantar la base, pero como .RDS y asignarla con el nombre _BaseRDS_ ¿tarda más o menos?


# Ejercicio de tarea

- Realizar mediante un loop, para cada una de las regiones,un gráfico de barras donde se comparen las tasas de desempleo de varones y mujeres en el 1er trimestre de 2017 (Pista: ver código del cálculo de la tasa en la clase 2, y del gráfico en la nota de clase 3)



