Capítulo 9 Programacion Funcional

Reiniciar R

library(tidyverse)
library(openxlsx)
library(ggthemes)
library(fs)

9.1 Loops

Un loop es una estructura de código que nos permite aplicar iterativamente un mismo conjunto de comandos, variando el valor de una variable. Por ejemplo:

for(i in 1:10){
   print(i^2)
}
## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25
## [1] 36
## [1] 49
## [1] 64
## [1] 81
## [1] 100

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”

for(Valores in 1:10){
   print(Valores^2)
  
}
## [1] 1
## [1] 4
## [1] 9
## [1] 16
## [1] 25
## [1] 36
## [1] 49
## [1] 64
## [1] 81
## [1] 100

Un loop puede iterar sobre cualquier tipo de vector, independientemente de lo que contenga.

Los loops son una estructura básica que existen en cualquier lenguaje de programación. En R no recomendamos abusar de ellos porque hacen que el código sea más lento.

9.2 Estructuras Condicionales

Las estructuras condiconales nos permiten ejecutar una porción de código en caso de que cumplan una condición lógica

9.2.1 if

Su funcionamiento es el siguiente:
if(condicion){codigo a ejecutar si se cumple la condición}

if( 2+2 == 4){
  print("Menos Mal")
}
## [1] "Menos Mal"
if( 2+2 == 148.24){
  print("R, tenemos un problema")
}

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

if_else(2+2==4, true = "Joya",false = "Error")
## [1] "Joya"

9.3 Funciones

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.

Por ejemplo, podemos definir la suma de dos elementos como

suma <- function(valor1, valor2) {
  valor1+valor2
}

suma(5,6)
## [1] 11

Obviamente las funciones no son sólo para variables numéricas. Por ejemplo, podemos pegar dos strings con una flecha en el medio

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

funcion_prueba(parametro1 = "A ver", parametro2 = "Que pasa")
## [1] "A ver <--> 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.

Otra_funcion_prueba <- function(parametro1 ,parametro2 = "String default") {
  paste(parametro1, parametro2, sep = " <--> ")
  
}
Otra_funcion_prueba(parametro1 = "Valor 1 ")
## [1] "Valor 1  <--> String default"

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

9.4 PURRR3

MAP es la forma tidy de hacer loops. Además de ser más prolijo el código, es mucho más eficiente.

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

ABC_123 <- data.frame(Letras = LETTERS[1:20],Num = 1:20)
funcion_prueba
## function(parametro1,parametro2) {
##   paste(parametro1, parametro2, sep = " <--> ")
## }

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

resultado <- map2(ABC_123$Letras,ABC_123$Num,funcion_prueba)
resultado[1:3]
## [[1]]
## [1] "A <--> 1"
## 
## [[2]]
## [1] "B <--> 2"
## 
## [[3]]
## [1] "C <--> 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í:

ABC_123 %>% 
  mutate(resultado= map2(Letras,Num,funcion_prueba))
##    Letras Num resultado
## 1       A   1  A <--> 1
## 2       B   2  B <--> 2
## 3       C   3  C <--> 3
## 4       D   4  D <--> 4
## 5       E   5  E <--> 5
## 6       F   6  F <--> 6
## 7       G   7  G <--> 7
## 8       H   8  H <--> 8
## 9       I   9  I <--> 9
## 10      J  10 J <--> 10
## 11      K  11 K <--> 11
## 12      L  12 L <--> 12
## 13      M  13 M <--> 13
## 14      N  14 N <--> 14
## 15      O  15 O <--> 15
## 16      P  16 P <--> 16
## 17      Q  17 Q <--> 17
## 18      R  18 R <--> 18
## 19      S  19 S <--> 19
## 20      T  20 T <--> 20

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

resultado[1:3] %>% unlist()
## [1] "A <--> 1" "B <--> 2" "C <--> 3"
ABC_123 %>% 
  mutate(resultado= unlist(map2(Letras,Num,funcion_prueba)))
##    Letras Num resultado
## 1       A   1  A <--> 1
## 2       B   2  B <--> 2
## 3       C   3  C <--> 3
## 4       D   4  D <--> 4
## 5       E   5  E <--> 5
## 6       F   6  F <--> 6
## 7       G   7  G <--> 7
## 8       H   8  H <--> 8
## 9       I   9  I <--> 9
## 10      J  10 J <--> 10
## 11      K  11 K <--> 11
## 12      L  12 L <--> 12
## 13      M  13 M <--> 13
## 14      N  14 N <--> 14
## 15      O  15 O <--> 15
## 16      P  16 P <--> 16
## 17      Q  17 Q <--> 17
## 18      R  18 R <--> 18
## 19      S  19 S <--> 19
## 20      T  20 T <--> 20

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.

map(ABC_123$Letras,funcion_prueba,ABC_123$Num)[1:2]
## [[1]]
##  [1] "A <--> 1"  "A <--> 2"  "A <--> 3"  "A <--> 4"  "A <--> 5" 
##  [6] "A <--> 6"  "A <--> 7"  "A <--> 8"  "A <--> 9"  "A <--> 10"
## [11] "A <--> 11" "A <--> 12" "A <--> 13" "A <--> 14" "A <--> 15"
## [16] "A <--> 16" "A <--> 17" "A <--> 18" "A <--> 19" "A <--> 20"
## 
## [[2]]
##  [1] "B <--> 1"  "B <--> 2"  "B <--> 3"  "B <--> 4"  "B <--> 5" 
##  [6] "B <--> 6"  "B <--> 7"  "B <--> 8"  "B <--> 9"  "B <--> 10"
## [11] "B <--> 11" "B <--> 12" "B <--> 13" "B <--> 14" "B <--> 15"
## [16] "B <--> 16" "B <--> 17" "B <--> 18" "B <--> 19" "B <--> 20"

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

ABC_123 %>% 
  mutate(resultado= map(Letras,funcion_prueba,Num))
##    Letras Num
## 1       A   1
## 2       B   2
## 3       C   3
## 4       D   4
## 5       E   5
## 6       F   6
## 7       G   7
## 8       H   8
## 9       I   9
## 10      J  10
## 11      K  11
## 12      L  12
## 13      M  13
## 14      N  14
## 15      O  15
## 16      P  16
## 17      Q  17
## 18      R  18
## 19      S  19
## 20      T  20
##                                                                                                                                                                                                            resultado
## 1  A <--> 1, A <--> 2, A <--> 3, A <--> 4, A <--> 5, A <--> 6, A <--> 7, A <--> 8, A <--> 9, A <--> 10, A <--> 11, A <--> 12, A <--> 13, A <--> 14, A <--> 15, A <--> 16, A <--> 17, A <--> 18, A <--> 19, A <--> 20
## 2  B <--> 1, B <--> 2, B <--> 3, B <--> 4, B <--> 5, B <--> 6, B <--> 7, B <--> 8, B <--> 9, B <--> 10, B <--> 11, B <--> 12, B <--> 13, B <--> 14, B <--> 15, B <--> 16, B <--> 17, B <--> 18, B <--> 19, B <--> 20
## 3  C <--> 1, C <--> 2, C <--> 3, C <--> 4, C <--> 5, C <--> 6, C <--> 7, C <--> 8, C <--> 9, C <--> 10, C <--> 11, C <--> 12, C <--> 13, C <--> 14, C <--> 15, C <--> 16, C <--> 17, C <--> 18, C <--> 19, C <--> 20
## 4  D <--> 1, D <--> 2, D <--> 3, D <--> 4, D <--> 5, D <--> 6, D <--> 7, D <--> 8, D <--> 9, D <--> 10, D <--> 11, D <--> 12, D <--> 13, D <--> 14, D <--> 15, D <--> 16, D <--> 17, D <--> 18, D <--> 19, D <--> 20
## 5  E <--> 1, E <--> 2, E <--> 3, E <--> 4, E <--> 5, E <--> 6, E <--> 7, E <--> 8, E <--> 9, E <--> 10, E <--> 11, E <--> 12, E <--> 13, E <--> 14, E <--> 15, E <--> 16, E <--> 17, E <--> 18, E <--> 19, E <--> 20
## 6  F <--> 1, F <--> 2, F <--> 3, F <--> 4, F <--> 5, F <--> 6, F <--> 7, F <--> 8, F <--> 9, F <--> 10, F <--> 11, F <--> 12, F <--> 13, F <--> 14, F <--> 15, F <--> 16, F <--> 17, F <--> 18, F <--> 19, F <--> 20
## 7  G <--> 1, G <--> 2, G <--> 3, G <--> 4, G <--> 5, G <--> 6, G <--> 7, G <--> 8, G <--> 9, G <--> 10, G <--> 11, G <--> 12, G <--> 13, G <--> 14, G <--> 15, G <--> 16, G <--> 17, G <--> 18, G <--> 19, G <--> 20
## 8  H <--> 1, H <--> 2, H <--> 3, H <--> 4, H <--> 5, H <--> 6, H <--> 7, H <--> 8, H <--> 9, H <--> 10, H <--> 11, H <--> 12, H <--> 13, H <--> 14, H <--> 15, H <--> 16, H <--> 17, H <--> 18, H <--> 19, H <--> 20
## 9  I <--> 1, I <--> 2, I <--> 3, I <--> 4, I <--> 5, I <--> 6, I <--> 7, I <--> 8, I <--> 9, I <--> 10, I <--> 11, I <--> 12, I <--> 13, I <--> 14, I <--> 15, I <--> 16, I <--> 17, I <--> 18, I <--> 19, I <--> 20
## 10 J <--> 1, J <--> 2, J <--> 3, J <--> 4, J <--> 5, J <--> 6, J <--> 7, J <--> 8, J <--> 9, J <--> 10, J <--> 11, J <--> 12, J <--> 13, J <--> 14, J <--> 15, J <--> 16, J <--> 17, J <--> 18, J <--> 19, J <--> 20
## 11 K <--> 1, K <--> 2, K <--> 3, K <--> 4, K <--> 5, K <--> 6, K <--> 7, K <--> 8, K <--> 9, K <--> 10, K <--> 11, K <--> 12, K <--> 13, K <--> 14, K <--> 15, K <--> 16, K <--> 17, K <--> 18, K <--> 19, K <--> 20
## 12 L <--> 1, L <--> 2, L <--> 3, L <--> 4, L <--> 5, L <--> 6, L <--> 7, L <--> 8, L <--> 9, L <--> 10, L <--> 11, L <--> 12, L <--> 13, L <--> 14, L <--> 15, L <--> 16, L <--> 17, L <--> 18, L <--> 19, L <--> 20
## 13 M <--> 1, M <--> 2, M <--> 3, M <--> 4, M <--> 5, M <--> 6, M <--> 7, M <--> 8, M <--> 9, M <--> 10, M <--> 11, M <--> 12, M <--> 13, M <--> 14, M <--> 15, M <--> 16, M <--> 17, M <--> 18, M <--> 19, M <--> 20
## 14 N <--> 1, N <--> 2, N <--> 3, N <--> 4, N <--> 5, N <--> 6, N <--> 7, N <--> 8, N <--> 9, N <--> 10, N <--> 11, N <--> 12, N <--> 13, N <--> 14, N <--> 15, N <--> 16, N <--> 17, N <--> 18, N <--> 19, N <--> 20
## 15 O <--> 1, O <--> 2, O <--> 3, O <--> 4, O <--> 5, O <--> 6, O <--> 7, O <--> 8, O <--> 9, O <--> 10, O <--> 11, O <--> 12, O <--> 13, O <--> 14, O <--> 15, O <--> 16, O <--> 17, O <--> 18, O <--> 19, O <--> 20
## 16 P <--> 1, P <--> 2, P <--> 3, P <--> 4, P <--> 5, P <--> 6, P <--> 7, P <--> 8, P <--> 9, P <--> 10, P <--> 11, P <--> 12, P <--> 13, P <--> 14, P <--> 15, P <--> 16, P <--> 17, P <--> 18, P <--> 19, P <--> 20
## 17 Q <--> 1, Q <--> 2, Q <--> 3, Q <--> 4, Q <--> 5, Q <--> 6, Q <--> 7, Q <--> 8, Q <--> 9, Q <--> 10, Q <--> 11, Q <--> 12, Q <--> 13, Q <--> 14, Q <--> 15, Q <--> 16, Q <--> 17, Q <--> 18, Q <--> 19, Q <--> 20
## 18 R <--> 1, R <--> 2, R <--> 3, R <--> 4, R <--> 5, R <--> 6, R <--> 7, R <--> 8, R <--> 9, R <--> 10, R <--> 11, R <--> 12, R <--> 13, R <--> 14, R <--> 15, R <--> 16, R <--> 17, R <--> 18, R <--> 19, R <--> 20
## 19 S <--> 1, S <--> 2, S <--> 3, S <--> 4, S <--> 5, S <--> 6, S <--> 7, S <--> 8, S <--> 9, S <--> 10, S <--> 11, S <--> 12, S <--> 13, S <--> 14, S <--> 15, S <--> 16, S <--> 17, S <--> 18, S <--> 19, S <--> 20
## 20 T <--> 1, T <--> 2, T <--> 3, T <--> 4, T <--> 5, T <--> 6, T <--> 7, T <--> 8, T <--> 9, T <--> 10, T <--> 11, T <--> 12, T <--> 13, T <--> 14, T <--> 15, T <--> 16, T <--> 17, T <--> 18, T <--> 19, T <--> 20

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

9.4.1 Iterando en la EPH

Lo primero que necesitamos es definir un vector o lista sobre el que iterar.

Por ejemplo, podemos armar un vector con los path a las bases individuales, con el comando fs::dir_ls

bases_individuales_path <- dir_ls(path = 'Fuentes/', regexp= 'individual')
bases_individuales_path
## Fuentes/usu_individual_t117.txt Fuentes/usu_individual_t216.txt 
## Fuentes/usu_individual_t316.txt Fuentes/usu_individual_t416.txt

Luego, como en la función que usamos para leer las bases definimos muchos parametros, nos podemos armar una función wrapper que sólo necesite un parámetro, y que simplifique la escritura del map

leer_base_eph <- function(path) {
  read.table(path,sep=";", dec=",", header = TRUE, fill = TRUE) %>% 
    select(ANO4,TRIMESTRE,REGION,P21,CH04, CH06)
}

bases_df <- tibble(bases_individuales_path) %>%
  mutate(base = map(bases_individuales_path, leer_base_eph))
bases_df
## # A tibble: 4 x 2
##   bases_individuales_path         base                 
##   <fs::path>                      <list>               
## 1 Fuentes/usu_individual_t117.txt <df[,6] [58,675 × 6]>
## 2 Fuentes/usu_individual_t216.txt <df[,6] [59,811 × 6]>
## 3 Fuentes/usu_individual_t316.txt <df[,6] [59,550 × 6]>
## 4 Fuentes/usu_individual_t416.txt <df[,6] [58,154 × 6]>

El resultado es un DF donde la columna base tiene en cada fila, otro DF con la base de la EPH de ese período. Esto es lo que llamamos un nested DF o dataframe nesteado pa les pibes.

Si queremos juntar todo, podemos usar unnest()

bases_df <- bases_df %>% unnest()
bases_df[1:10,]
## # A tibble: 10 x 7
##    bases_individuales_path          ANO4 TRIMESTRE REGION   P21  CH04  CH06
##    <fs::path>                      <int>     <int>  <int> <int> <int> <int>
##  1 Fuentes/usu_individual_t117.txt  2017         1     43     0     2    18
##  2 Fuentes/usu_individual_t117.txt  2017         1     43     0     2    13
##  3 Fuentes/usu_individual_t117.txt  2017         1     43     0     1    15
##  4 Fuentes/usu_individual_t117.txt  2017         1     43     0     2    11
##  5 Fuentes/usu_individual_t117.txt  2017         1     43     0     1     7
##  6 Fuentes/usu_individual_t117.txt  2017         1     43     0     2     4
##  7 Fuentes/usu_individual_t117.txt  2017         1     43     0     2    17
##  8 Fuentes/usu_individual_t117.txt  2017         1     43     0     1     1
##  9 Fuentes/usu_individual_t117.txt  2017         1     43  1500     1    20
## 10 Fuentes/usu_individual_t117.txt  2017         1     43     0     2     1

¿Qué pasa si los DF que tenemos nesteados no tienen la misma cantidad de columnas?

Esto mismo lo podemos usar para fragmentar el datastet por alguna variable, con el group_by()

bases_df %>% 
  group_by(REGION) %>% 
  nest()
## # A tibble: 6 x 2
##   REGION data                 
##    <int> <list>               
## 1     43 <tibble [68,274 × 6]>
## 2     41 <tibble [23,302 × 6]>
## 3     44 <tibble [29,033 × 6]>
## 4     42 <tibble [21,997 × 6]>
## 5     40 <tibble [49,560 × 6]>
## 6      1 <tibble [44,024 × 6]>

Así, para cada región tenemos un DF.

¿ De qué sirve todo esto?

No todo en la vida es un Dataframe. Hay estucturas de datos que no se pueden normalizar a filas y columnas. En esos casos recurríamos tradicionalmente a los loops. Con MAP podemos tener los elementos agrupados en un sólo objeto y aún conservar sus formas diferentes.

9.5 Ejemplo. Regresión lineal

Si bien no nos vamos a meter en el detalle del modelo lineal, es útil usarlo como ejemplo de lo que podemos hacer con MAP.

Planteamos el modelo \[ P21 = \beta_0 + \beta_1*CH04 + \beta_2*CH06 \] Osea, un modleo que explica el ingreso según sexo y edad

lmfit <- lm(P21~factor(CH04)+CH06,data = bases_df)

summary(lmfit)
## 
## Call:
## lm(formula = P21 ~ factor(CH04) + CH06, data = bases_df)
## 
## Residuals:
##    Min     1Q Median     3Q    Max 
##  -8449  -3631  -1938    705 393616 
## 
## Coefficients:
##                 Estimate Std. Error t value Pr(>|t|)    
## (Intercept)    2599.1101    29.0732   89.40   <2e-16 ***
## factor(CH04)2 -2250.9637    28.3026  -79.53   <2e-16 ***
## CH06             57.3490     0.6347   90.35   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 6858 on 236187 degrees of freedom
## Multiple R-squared:  0.05449,    Adjusted R-squared:  0.05448 
## F-statistic:  6805 on 2 and 236187 DF,  p-value: < 2.2e-16

(al final de la clase podemos charlar sobre los resultados, si hay interés :-) )

De forma Tidy, la librería broom nos da los resultados en un DF.

broom::tidy(lmfit)
## # A tibble: 3 x 5
##   term          estimate std.error statistic p.value
##   <chr>            <dbl>     <dbl>     <dbl>   <dbl>
## 1 (Intercept)     2599.     29.1        89.4       0
## 2 factor(CH04)2  -2251.     28.3       -79.5       0
## 3 CH06              57.3     0.635      90.4       0

Si lo queremos hacer por region

9.5.1 Loopeando

resultados <- tibble()

for (region in unique(bases_df$REGION)) {
  
  data <- bases_df %>% 
    filter(REGION==region)
  
  lmfit <- lm(P21~factor(CH04)+CH06,data = data)
  
  lmtidy <- broom::tidy(lmfit)
  lmtidy$region <- region
  resultados <- bind_rows(resultados,lmtidy)

}

resultados[1:10,]
## # A tibble: 10 x 6
##    term          estimate std.error statistic   p.value region
##    <chr>            <dbl>     <dbl>     <dbl>     <dbl>  <int>
##  1 (Intercept)     2665.      50.2       53.1 0.            43
##  2 factor(CH04)2  -2045.      48.6      -42.1 0.            43
##  3 CH06              41.6      1.06      39.0 0.            43
##  4 (Intercept)     1808.      69.2       26.1 2.37e-148     41
##  5 factor(CH04)2  -1808.      67.6      -26.8 2.70e-155     41
##  6 CH06              55.6      1.58      35.2 7.99e-265     41
##  7 (Intercept)     3726.     115.        32.3 4.35e-225     44
##  8 factor(CH04)2  -3337.     112.       -29.8 1.23e-192     44
##  9 CH06              93.4      2.58      36.2 3.12e-280     44
## 10 (Intercept)     2674.      81.7       32.7 1.28e-229     42

9.5.2 Usando MAP

Primero me armo una funcion que me simplifica el codigo

fun<-function(porcion,grupo) {  broom::tidy(lm(P21~factor(CH04)+CH06,data = porcion))}
bases_df_lm <- bases_df %>% 
  group_by(REGION) %>%
  nest() %>% 
  mutate(lm = map(data,fun))
bases_df_lm
## # A tibble: 6 x 3
##   REGION data                  lm              
##    <int> <list>                <list>          
## 1     43 <tibble [68,274 × 6]> <tibble [3 × 5]>
## 2     41 <tibble [23,302 × 6]> <tibble [3 × 5]>
## 3     44 <tibble [29,033 × 6]> <tibble [3 × 5]>
## 4     42 <tibble [21,997 × 6]> <tibble [3 × 5]>
## 5     40 <tibble [49,560 × 6]> <tibble [3 × 5]>
## 6      1 <tibble [44,024 × 6]> <tibble [3 × 5]>
bases_df_lm %>% 
  unnest(lm) %>% 
  top_n(10)
## Selecting by p.value
## # A tibble: 10 x 6
##    REGION term          estimate std.error statistic   p.value
##     <int> <chr>            <dbl>     <dbl>     <dbl>     <dbl>
##  1     41 (Intercept)     1808.      69.2       26.1 2.37e-148
##  2     41 factor(CH04)2  -1808.      67.6      -26.8 2.70e-155
##  3     44 (Intercept)     3726.     115.        32.3 4.35e-225
##  4     44 factor(CH04)2  -3337.     112.       -29.8 1.23e-192
##  5     42 (Intercept)     2674.      81.7       32.7 1.28e-229
##  6     42 factor(CH04)2  -2250.      79.7      -28.2 1.98e-172
##  7     42 CH06              52.0      1.75      29.7 2.70e-190
##  8     40 (Intercept)     1758.      51.3       34.3 2.09e-254
##  9      1 factor(CH04)2  -2411.      74.3      -32.4 3.61e-228
## 10      1 CH06              53.1      1.62      32.7 3.34e-232

O incluso más facil, utilizando group_modify (que es un atajo que solo acepta DF)

bases_df %>% 
  group_by(REGION) %>% 
  group_modify(fun) %>% 
  top_n(10)
## Selecting by p.value
## # A tibble: 18 x 6
## # Groups:   REGION [6]
##    REGION term          estimate std.error statistic   p.value
##     <int> <chr>            <dbl>     <dbl>     <dbl>     <dbl>
##  1      1 (Intercept)     2993.      77.0       38.9 0.       
##  2      1 factor(CH04)2  -2411.      74.3      -32.4 3.61e-228
##  3      1 CH06              53.1      1.62      32.7 3.34e-232
##  4     40 (Intercept)     1758.      51.3       34.3 2.09e-254
##  5     40 factor(CH04)2  -1924.      50.5      -38.1 1.58e-313
##  6     40 CH06              68.6      1.18      58.1 0.       
##  7     41 (Intercept)     1808.      69.2       26.1 2.37e-148
##  8     41 factor(CH04)2  -1808.      67.6      -26.8 2.70e-155
##  9     41 CH06              55.6      1.58      35.2 7.99e-265
## 10     42 (Intercept)     2674.      81.7       32.7 1.28e-229
## 11     42 factor(CH04)2  -2250.      79.7      -28.2 1.98e-172
## 12     42 CH06              52.0      1.75      29.7 2.70e-190
## 13     43 (Intercept)     2665.      50.2       53.1 0.       
## 14     43 factor(CH04)2  -2045.      48.6      -42.1 0.       
## 15     43 CH06              41.6      1.06      39.0 0.       
## 16     44 (Intercept)     3726.     115.        32.3 4.35e-225
## 17     44 factor(CH04)2  -3337.     112.       -29.8 1.23e-192
## 18     44 CH06              93.4      2.58      36.2 3.12e-280

Pero MAP sirve para operar con cualquier objeto de R.

Por ejemplo podemos guardar el objeto S3:lm que es la regresion lineal entrenada. Ese objeto no es ni un vector, ni una lista, ni un DF. No es una estructura de datos, sino que es algo distinto, con propiedades como predict() para predecir, el summary() que vimos, etc.

fun<-function(porcion,grupo) {  lm(P21~factor(CH04)+CH06,data = porcion)}

bases_df %>% 
  group_by(REGION) %>%
  nest() %>%  
  mutate(lm = map(data,fun))
## # A tibble: 6 x 3
##   REGION data                  lm    
##    <int> <list>                <list>
## 1     43 <tibble [68,274 × 6]> <lm>  
## 2     41 <tibble [23,302 × 6]> <lm>  
## 3     44 <tibble [29,033 × 6]> <lm>  
## 4     42 <tibble [21,997 × 6]> <lm>  
## 5     40 <tibble [49,560 × 6]> <lm>  
## 6      1 <tibble [44,024 × 6]> <lm>

9.5.3 Walk

Las funciones Walk Tienen la misma forma que los map, pero se usan cuando lo que queremos iterar no genera una salida, sino que nos interesan los efectos secundarios que generan.

map2(ABC_123$Letras,ABC_123$Num,funcion_prueba)[1:3]
## [[1]]
## [1] "A <--> 1"
## 
## [[2]]
## [1] "B <--> 2"
## 
## [[3]]
## [1] "C <--> 3"
walk2(ABC_123$Letras,ABC_123$Num,funcion_prueba)
imprimir_salida <- function(x,y){
  print(funcion_prueba(x,y))
}

walk2(ABC_123$Letras,ABC_123$Num,imprimir_salida)
## [1] "A <--> 1"
## [1] "B <--> 2"
## [1] "C <--> 3"
## [1] "D <--> 4"
## [1] "E <--> 5"
## [1] "F <--> 6"
## [1] "G <--> 7"
## [1] "H <--> 8"
## [1] "I <--> 9"
## [1] "J <--> 10"
## [1] "K <--> 11"
## [1] "L <--> 12"
## [1] "M <--> 13"
## [1] "N <--> 14"
## [1] "O <--> 15"
## [1] "P <--> 16"
## [1] "Q <--> 17"
## [1] "R <--> 18"
## [1] "S <--> 19"
## [1] "T <--> 20"

Eso que vemos es el efecto secundario dentro de la función (imprimir)

9.5.4 Discusión.

Cuando usar estas herramientas?

A lo largo del curso vimos diferentes técnicas para manipulación de datos. En particular, la librería dplyr nos permitía fácilmente modificar y crear nuevas variables, agrupando. Cuando usamos dplyr y cuando usamos purrr.

  • Si trabajamos sobre un DF simple, sin variables anidadas (lo que conocíamos hasta hoy) podemos usar dplyr

  • Si queremos trabajar con DF anidados, con cosas que no son DF, o si el resultado de la operación que vamos a realizar a nivel file es algo distinto a un valor único, nos conviene usar map y purrr

  • Las funciones walk son útiles por ejemplo para escribir archivos en disco de forma iterativa. Algo que no genera una salida

9.6 Lectura y escritura de archivos intermedia

R tiene formatos de archivos propios:

  • Rdata
  • RDS

9.6.1 RData

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.

9.6.2 RDS

x
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
saveRDS(x, "x.RDS")

Z <- readRDS("x.RDS")
Z
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

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

9.6.3 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()

9.6.4 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. Limpiar la memoria rm(list=ls())
  2. Cargar librerías
  3. Definir funciones
  4. Levantar archivos
    … procesamiento ….
  1. 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 ###

9.7 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 tiene unos machetes muy útiles

  • Rdocumentation

  • stack overflow 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)

9.8 Ejercicios para practicar

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

  • Crear una función que calcule la frecuencia expandida por un PONDERA

  • Utilizar dicha función para calcular la frecuencia poblaciónal por Sexo y Región

  • Modificar la función anterior para que devuelva un vector con la frecuencia muestra y la frecuencia poblacional

  • Utilizar la función modificada para calcular la frecuencias frecuencias muestrales y poblacionales por Sexo y Región

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

  1. basado en https://jennybc.github.io/purrr-tutorial/ls03_map-function-syntax.html↩