Clase 1. Introducción

Descripción del programa

https://cran.r-project.org/

¿Que es R?

• Lenguaje de Análisis de Datos
• Software Libre
• Sintaxis Básica: R base
• Sintaxis incremental¹: El lenguaje se va ampliando por aportes de Universidades, investigadores y empresas privadas, organizados en librerías (o paquetes)
• Comunidad web muy grande para realizar preguntas y despejar dudas.

fuente: https://gist.github.com/daroczig/3cf06d6db4be2bbe3368

https://www.rstudio.com/

El entorno más cómodo para utilizar el lenguaje R es el programa R studio

• Rstudio es una empresa que produce productos asociados al lenguaje R, como el programa sobre el que corremos los comandos, y extensiones del lenguaje (librerías).

• El programa es gratuito y se puede bajar de la página oficial

Pantalla Rstudio

fuente: https://github.com/matthieugomez/benchmark-stata-r/blob/master/output/1e7.png

Lógica sintáctica

Definición de objetos

El operador <- sirve para definir un elemento. A la izquierda del <- debe ubicarse el nombre que tomará el elemento a crear. Del lado derecho debe ir la definición del mismo

A <- 1

Al definir un elemento, el mismo queda guardado en el ambiente del programa, y podrá ser utilizado posteriormente para observar su contenido o para realizar una operación con el mismo

A 

[1] 1

Al correr una linea con el nombre del objeto, la consola del programa nos muestra su contenido. Entre Corchetes Observamos el número de orden del elemento en cuestión

El operador = es equivalente a <-, pero en la práctica no se utiliza para la definición de objetos.

B = 2
B

[1] 2

<- es un operador Unidireccional, es decir que:
A <- B implica que A va tomar como valor el contenido del objeto B, y no al revés.

A <- B
A   #Ahora A toma el valor de B, y B continua conservando el mismo valor

[1] 2

B

[1] 2

R base

Con R base nos referimos a los comandos básicos que vienen incorporados en el R, sin necesidad de cargar librerías.

Operadores lógicos:

• \(>\)
• \(>=\)
• \(<\)
• \(<=\)
• \(==\)
• \(!=\)

A = 1
B = 2
A >  B

[1] FALSE

A >= B

[1] FALSE

A <  B

[1] TRUE

A <= B

[1] TRUE

A == B

[1] FALSE

A != B

[1] TRUE

C <- A != B
C

[1] TRUE

Como muestra el último ejemplo, el resultado de una operación lógica puede almacenarse como el valor de un objeto.

Operadores aritméticos:

#suma
A <- 5+6
A

[1] 11

#Resta
B <- 6-8
B

[1] -2

#cociente
C <- 6/2.5
C

[1] 2.4

#multiplicacion
D <- 6*2.5
D

[1] 15

# Modulo
E <- 7%%2
E

[1] 1

Caracteres especiales

• R es sensible a mayúsculas y minúsculas, tanto para los nombres de las variables, como para las funciones y parámetros.
• Los espacios en blanco y los carriage return (enter) no son considerados por el lenguaje. Los podemos aprovechar para emprolijar el código y que la lectura sea más simple².

• El numeral # se utiliza para hacer comentarios. Todo lo que se escribe después del # no es interpretado por R. Se debe utilizar un # por cada línea de código que se desea anular. SHORTCUT: En R-Studio se puede seleccionar todo un bloque de texto y comentarlo completo apretando CTRL+SHIFT+C

• Los corchetes [] se utilizan para acceder a un objeto:
  • en un vector[n° orden]
  • en una matriz[fila, columna]
  • en una lista[n° elemento]

• el signo $ también es un método de acceso, que permite llamar al elemento por su nombre, en dataframes y listas.

• Los paréntesis() se utilizan en las funciones para definir los parámetros.

• Las comas , se utilizan para separar los elementos.

Ejemplo: si queremos definir al elemento de la fila 2 y columna 3 de una tabla como el resultado de una funcion con parámetros A=a, B=b y C=c, diremos:

tabla[2,3] <- funcion(A=a, B=b, C=c)

Tipos de datos y estructuras de datos:

Los tipos de datos son una clase de valores que se pueden construir para representar información. Las estructuras de datos son formas de representar y guardar información

Tipos de datos

Los datos tienen distintos tipos:

• El comando class() identifica el tipo de un objeto desde una perspectiva de programación orientada a objetos en R. Podemos redifinir la clase de un objeto
• El comando type() identifica el tipo de un objeto según el lenguaje R. No podemos modificar el tipo de un objeto

Numeric

A <- 1
class(A)   

[1] "numeric"

typeof(A)

[1] "double"

Tratemos de cambiar la clase y el tipo de nuestro objeto

class(A) <- "nueva_clase"
class(A)

[1] "nueva_clase"

typeof(A) <- "nuevo_tipo"

Error in typeof(A) <- "nuevo_tipo" : could not find function "typeof<-"

Integer

A <- 1L
A

[1] 1

class(A)   

[1] "integer"

typeof(A)

[1] "integer"

Complex

A <- 2+2i
A

[1] 2+2i

class(A)   

[1] "complex"

typeof(A)

[1] "complex"

Character

A <-  paste('Soy', 'una', 'concatenación', 'de', 'caracteres', sep = " ")
A

[1] "Soy una concatenación de caracteres"

class(A)

[1] "character"

typeof(A)

[1] "character"

Factor

A <- factor("Soy un factor con niveles fijos")
A

[1] Soy un factor con niveles fijos
Levels: Soy un factor con niveles fijos

class(A)

[1] "factor"

typeof(A)

[1] "integer"

La diferencia entre un character y un factor es que el último tiene solo algunos valores permitidos (levels), y se le puede dar un orden

A <- factor(c("R","Weka","SPSS","SAS","R"))
A

[1] R    Weka SPSS SAS  R   
Levels: R SAS SPSS Weka

class(A)

[1] "factor"

typeof(A)

[1] "integer"

# ¿Cuáles son sus niveles?
levels(A)

[1] "R"    "SAS"  "SPSS" "Weka"

# ¿Está ordenado?
is.ordered(A)

[1] FALSE

A <- factor(c("R","Weka","SPSS","SAS","R"), ordered = TRUE)
A

[1] R    Weka SPSS SAS  R   
Levels: R < SAS < SPSS < Weka

class(A)

[1] "ordered" "factor" 

typeof(A)

[1] "integer"

# ¿Cuáles son sus niveles?
levels(A)

[1] "R"    "SAS"  "SPSS" "Weka"

# ¿Está ordenado?
is.ordered(A)

[1] TRUE

# ¿Podemos cambiar el orden de los niveles?
A <- factor(c("R","Weka","SPSS","SAS","R"), ordered = TRUE, levels = c("SPSS","SAS","Weka","R"))
A

[1] R    Weka SPSS SAS  R   
Levels: SPSS < SAS < Weka < R

Logical

A <- TRUE
class(A)

[1] "logical"

typeof(A)

[1] "logical"

Date

A <- as.Date("2017-01-01")
class(A)

[1] "Date"

typeof(A)

[1] "double"

Estructuras de datos

Vectores

Para crear un vector utilizamos el comando c(), de combinar. Puede tener variables de cualquier tipo

C <- c(1, 3, 4)
C

[1] 1 3 4

typeof(C)

[1] "double"

class(C)

[1] "numeric"

# ¿Qué longitud tiene?
length(C)

[1] 3

# ¿Cuáles son sus dimensiones?
dim(C)

NULL

sumarle 2 a cada elemento del vector anterior

C <- C + 2
C

[1] 3 5 6

sumarle 1 al primer elemento, 2 al segundo, y 3 al tercer elemento del vector anterior

D <- C + 1:3 #esto es equivalente a hacer 3+1, 5+2, 6+9 
D

[1] 4 7 9

1:3 significa que queremos todos los números enteros desde 1 hasta 3.

Reciclaje de vectores

Cuando los vectores involucrados en una operación son distinta dimensión, R recicla el vector de menor longitud para poder completar la operación.

v1 <- c(10,20,30,40,50,60)
v2 <- c(1,2,3)
v3 <- v1 + v2
v3

[1] 11 22 33 41 52 63

# ¿Qué pasa si el vector más pequeño no es multiplo del más grande?
v2 <- c(1,2,3,4)
v3 <- v1 + v2

longer object length is not a multiple of shorter object length

v3

[1] 11 22 33 44 51 62

Puede contener datos tipo “character”

E <- c("Julia","Hadley","Guido")
E

[1] "Julia"  "Hadley" "Guido" 

Para acceder a algún elemento del vector, podemos buscarlo por su número de orden, entre [ ]

elemento2 <- E[2]
elemento2

[1] "Hadley"

para borrar un objeto, utilizamos el comando rm()

rm(elemento2)
elemento2

Error: object 'elemento2' not found

También podemos cambiar el texto del segundo elemento de E, por el texto “var”

E[2] <- "Pablo"
E

[1] "Julia" "Pablo" "Guido"

Matrices

Son vectores que poseen dimensiones: número de columnas y filas. Todos sus datos deben ser de un mismo tipo

# Esta forma de construir la matriz es por columnas por default
M <- matrix(1:9, nrow = 3, ncol = 3)
M

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

typeof(M)

[1] "integer"

class(M)

[1] "matrix"

# ¿Qué longitud tiene?
length(M)

[1] 9

# ¿Cuáles son sus dimensiones?
dim(M)

[1] 3 3

También podemos reciclar vectores al construir una matriz

Otra forma de construir una matriz es uniendo dos o más vectores

v1 <- c(1,2,3)
v2 <- c(4,5,6)
# Creamos la matriz uniendo los dos vectores con cbind()
M <- cbind(v1,v2)
M

     v1 v2
[1,]  1  4
[2,]  2  5
[3,]  3  6

typeof(M)

[1] "double"

class(M)

[1] "matrix"

# ¿Qué longitud tiene?
length(M)

[1] 6

# ¿Cuáles son sus dimensiones?
dim(M)

[1] 3 2

¿Qué pasa si queremos sumar una columna con otro tipo de datos?

v3 <- c("a","b","c")
M <- cbind(M,v3)
M

     v1  v2  v3 
[1,] "1" "4" "a"
[2,] "2" "5" "b"
[3,] "3" "6" "c"

typeof(M)

[1] "character"

class(M)

[1] "matrix"

Data Frames

Un Data Frame es una tabla de datos, donde cada columna representa una variable, y cada fila una observación.

Este objeto suele ser central en el proceso de trabajo, y suele ser la forma en que se cargan datos externos, así como la mayoría de los elementos intermedios, hasta aquello que exportemos

También Se puede crear como la combinación de N vectores de igual tamaño. Por ejemplo, tomamos algunos valores del Indice de salarios

INDICE  <- c(100,   100,   100,
             101.8, 101.2, 100.73,
             102.9, 102.4, 103.2)
FECHA  <-  c("Oct-16", "Oct-16", "Oct-16",
             "Nov-16", "Nov-16", "Nov-16",
             "Dic-16", "Dic-16", "Dic-16")
GRUPO  <-  c("Privado_Registrado","Público","Privado_No_Registrado",
             "Privado_Registrado","Público","Privado_No_Registrado",
             "Privado_Registrado","Público","Privado_No_Registrado")
             
Datos <- data.frame(INDICE, FECHA, GRUPO)
Datos

Tal como en un vector se ubica a los elementos mediante [ ], en un dataframe se obtienen sus elementos de la forma [fila, columna].

Otra opción es seleccionar la columna, mediante el operador $, y luego seleccionar dentro de esa columna, por el número de orden.

Datos$FECHA

[1] Oct-16 Oct-16 Oct-16 Nov-16 Nov-16 Nov-16 Dic-16 Dic-16 Dic-16
Levels: Dic-16 Nov-16 Oct-16

Datos[3,2]

[1] Oct-16
Levels: Dic-16 Nov-16 Oct-16

Datos$FECHA[3]

[1] Oct-16
Levels: Dic-16 Nov-16 Oct-16

¿que pasa si hacemos Datos$FECHA[3,2] ?

Datos$FECHA[3,2]

Error in `[.default`(Datos$FECHA, 3, 2) : incorrect number of dimensions

Nótese que el último comando tiene un número incorrecto de dimensiones, porque estamos refiriendonos 2 veces a la columna FECHA.

Listas

Contienen una concatenación de objetos de cualquier tipo. Así como un vector contiene valores, un dataframe contiene vectores, una lista puede contener dataframes, pero también vectores, o valores, y todo ello a la vez

superlista <- list(A,B,C,D,E,FECHA, DF = Datos, INDICE, GRUPO)
superlista

[[1]]
[1] "2017-01-01"

[[2]]
[1] -2

[[3]]
[1] 3 5 6

[[4]]
[1] 4 7 9

[[5]]
[1] "Julia" "Pablo" "Guido"

[[6]]
[1] "Oct-16" "Oct-16" "Oct-16" "Nov-16" "Nov-16" "Nov-16" "Dic-16" "Dic-16" "Dic-16"

$DF

[[8]]
[1] 100.00 100.00 100.00 101.80 101.20 100.73 102.90 102.40 103.20

[[9]]
[1] "Privado_Registrado"    "Público"               "Privado_No_Registrado" "Privado_Registrado"   
[5] "Público"               "Privado_No_Registrado" "Privado_Registrado"    "Público"              
[9] "Privado_No_Registrado"

Para acceder un elemento de una lista, podemos utilizar el operador $, que se puede usar a su vez de forma iterativa

superlista$DF$FECHA[2]

[1] Oct-16
Levels: Dic-16 Nov-16 Oct-16

Loops, condicionales y funciones

Loops

Un loop es una estructura de código que nos permite recorrer iterativamente un conjunto de comandos, variando algún elemento. Por ejemplo:

for(i in 1:10){
  Cuadrados<- i^2
  print(Cuadrados)
}

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36
[1] 49
[1] 64
[1] 81
[1] 100

esto se lee como : Para i, que toma los valores de 1 a 10:

• Calcula el cuadrado de i y definilo como Cuadrado
• Imprimí a Cuadrado

También se puede tomar una lista de valores cualesquiera. Por ejemplo reutilizar datos de un dataframe:

Datos

unique(Datos$GRUPO)

[1] Privado_Registrado    Público               Privado_No_Registrado
Levels: Privado_No_Registrado Privado_Registrado Público

for(variable in unique(Datos$GRUPO)){
  print(Datos[Datos$GRUPO == variable,])
}

Bonus Track: Podemos agregar una barra de progreso en nuestro loop

\ En un Rnotebook no sirve de mucho, pero en un script puede ser útil para loop largos. Sobretodo, es útil cuando tengamos loops adentro de funciones

iterator <- c(1:10)
pb <- txtProgressBar(min = 0, max = length(iterator), style = 3)  

  |                                                                                                     
  |                                                                                               |   0%

stepi =1
for(i in iterator){
  setTxtProgressBar(pb, stepi)
  stepi = stepi+1
  Cuadrados<- i^2
  print(Cuadrados)
}

  |                                                                                                     
  |==========                                                                                     |  10%[1] 1

  |                                                                                                     
  |===================                                                                            |  20%[1] 4

  |                                                                                                     
  |============================                                                                   |  30%[1] 9

  |                                                                                                     
  |======================================                                                         |  40%[1] 16

  |                                                                                                     
  |================================================                                               |  50%[1] 25

  |                                                                                                     
  |=========================================================                                      |  60%[1] 36

  |                                                                                                     
  |==================================================================                             |  70%[1] 49

  |                                                                                                     
  |============================================================================                   |  80%[1] 64

  |                                                                                                     
  |======================================================================================         |  90%[1] 81

  |                                                                                                     
  |===============================================================================================| 100%[1] 100

close(pb)

Estructuras condicionales

Las estructuras condicionales nos permiten definir flujos de ejecución del código, indicando qué se debe correr en cada circunstancia.

A <- 'Esto no es una cadena de caracteres'
B <- factor('Esto no es una cadena de caracteres')
# Condicional simple
if (class(A) == "character") {
  print("No le crean, esto es una cadena de caracteres")
} 

[1] "No le crean, esto es una cadena de caracteres"

# Condicional simple
if (class(B) == "character") {
  print("No le crean, esto es una cadena de caracteres")
} 
# Condicional exhaustivo
if (class(B) == "character") {
  print("No le crean, esto es una cadena de caracteres")
} else {print("Esta chequeado, esto NO es una cadena de caracteres")}

[1] "Esta chequeado, esto NO es una cadena de caracteres"

Una forma más sencilla y explícita es usar el comando ifelse.

ifelse(test = class(A) == "character", yes =  "Esto es un caracter",
       no = "Esto no era un caracter")

[1] "Esto es un caracter"

Funciones

Las funciones nos permiten 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.

funcion_prueba <- function(a,b) {
  print(paste(a, b, sep = " "))
  
}
funcion_prueba(a = "Soy la primera parte de un string.", b = "Y yo la segunda parte")

[1] "Soy la primera parte de un string. Y yo la segunda parte"

También podemos asignar un valor por default.

funcion_prueba <- function(a = "Soy un default.",b) {
  print(paste(a, b, sep = " "))
  
}
funcion_prueba(b = " A mi me tenes que asignar")

[1] "Soy un default.  A mi me tenes que asignar"

funcion_prueba(a='Lo puedo asignar?', b='Obvio')

[1] "Lo puedo asignar? Obvio"

Las funciones que creamos nosotros viven dentro del script donde se las define. Es decir, es necesario volver a correr la definición cada vez que la queremos utilizar.

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

AYUDA: En R-Studio se puede acceder a las definición de una función clickeando la función mientras apretamos CTRL

Ejercicio 1

Realicen una función que:

• Toma como argumento una matriz compuesta por números
• Debe imprimir las dimensiones de la matriz
• Debe indicar si el primer elemento de la matriz es un número par
• Para la matriz m1 debe imprimir que las dimensiones son 2,2 y que el primer elemento no es par
• Para la matriz m2 debe imprimir que las dimensiones son 3,2 y que el primer elemento es par

m1 <- matrix(c(9,2,4,8), nrow = 2, ncol = 2)
m2 <- matrix(c(10,1,5,7,9,17), nrow = 3, ncol = 2)

Funciones anónimas

Son funciones a las cuales no les asignamos un nombre. Esto suele ser útil para hacer funciones pequeñas dentro de otras funciones o estructuras más complejas.

(function(x) x*2)(10)

[1] 20

Funciones apply

Los loops que vimos anteriormente ( for loops) suelen lentos y costosos computacionalmente para grandes conjuntos de datos.

La función apply y sus variantes brindan una alternativa más eficiente para aplicar funciones sobre un conjunto de datos.

La función apply se describe de la siguiente manera: apply(X, MARGIN, FUN, …). Sus parámetros son:

• X: estructura de datos
• MARGIN: parámetro que indica como se aplica la función. Con MARGIN=1 se aplica sobre filas y con MARGIN=2 se aplica sobre columnas
• FUN: función a aplicar

# Armamos un dataframe con la recaudación en millones de dolares de la trilogía de Batman de Nolan
USA  <- c(207,   535,   448)
Mundo <- c(167,   470,   636)
pelis  <-  c("Batman Begins", "Dark Knight", "Dark Knight Rises")
batman <- data.frame(USA, Mundo, row.names = pelis)
batman

# ¿Cuanto recaudó cada película?
apply(X=batman, MARGIN =1 , FUN=sum)

    Batman Begins       Dark Knight Dark Knight Rises 
              374              1005              1084 

# ¿Cuanto recaudó en promedio la trilogía por área?
apply(X=batman, MARGIN =2 , FUN=mean)

     USA    Mundo 
396.6667 424.3333 

# ¿Cuanto recaudó cada película en pesos argentinos?
apply(X=batman, MARGIN =1 , FUN=sum*30.4)

Error in sum * 30.4 : non-numeric argument to binary operator

# Funciones anónimas al rescate
apply(X=batman, MARGIN =1 , FUN=function(x) sum(x)*30.4)

    Batman Begins       Dark Knight Dark Knight Rises 
          11369.6           30552.0           32953.6 

Ejercicio 2

1. Crear un dataframe con el dataset de R: state.x77
2. Responder:

1. ¿Cuál es la población total de Estados Unidos?
2. ¿Cuál es la media de la expectativa de vida?
3. ¿Cual es la mediana del ingreso en pesos argentinos?

3. Seleccionar las variables illiteracy y Murder. Crear un indice sumando ambos porcentajes y encontrar cual es el mejor y cual es el peor Estado según este índice

Lectura y escritura de archivos

R tiene formatos de archivos propios:

• Rdata
• RDS

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.

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)

Archivos de otros formatos

Hay muchas funciones para leer archivos de tipo .txt y .csv. La mayoría sólo cambia los parámetros que vienen por default.

Es importante tener en cuenta:

• encabezado
• delimitador (,, tab, ;)
• separador decimal

dataframe <- read.delim(file, header = TRUE, sep = "\t", quote = "\"", dec = ".", fill = TRUE, comment.char = "", ...) 

Ejemplo. Levantar la base individual de EPH del 1er trimestre 2017

individual_t117 <- read.table('../Fuentes/usu_individual_t117.txt',sep=";", dec=",", header = TRUE, fill = TRUE)
head(individual_t117)

Excel

Para leer archivos excel debemos utilizar los comandos que vienen con la librería xlsx

# install.packages("xlsx") # por única vez
library(xlsx) #activamos la librería
#creamos una tabla cualquiera de prueba
x <- 1:10
y <- 11:20
tabla_de_R <- data.frame(x,y)
# escribimos el archivo
write.xlsx( x = tabla_de_R, file = "archivo.xlsx",sheetName = "hoja 1",row.names = FALSE)
#leemos el archivo
tabla <- read.xlsx(file = "archivo.xlsx",sheetName = "hoja 1")
tabla

SPSS, STATA, SAS

Podemos utilizar la librería haven, y los comandos:

• 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 la forma mediante la 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

Directorios

Siempre que escribimos el nombre del archivo, R lo busca en el working directory. Para saber cual es el directorio de trabajo utilizamos la función getwd(). Para redefinir el directorio de trabajo, utilizamos la función setwd

No es aconsejable utilizar el directorio de trabajo, si nos olvidamos de definirlo, tiramos los archivos en cualquier lado

Lo más práctico es definir los directorios de trabajo como valores. y pegar el nombre del archivo con las carpetas.

carpeta_fuentes    <- paste("C:/Users/.../Documents/R/fuentes/")
carpeta_resultados <- paste("C:/Users/.../Documents/R/resultados/")

Es importante notar que se utiliza la barra / en lugar de \ (que sale de copiar y pegar el directorio en windows)

el nombre completo del archivo puede ser

archivo_datos      <- paste0(carpeta_fuentes, "archivo_fuentes.txt")
archivo_resultados <- paste0(carpeta_resultados, "archivo_resultados.txt")

luego, para leer un excel, se escribe:

tabla <- read.xlsx(file = archivo_datos,sheetName = "hoja 1") #como es una variable, ya no lleva comillas

Directorios autorreferenciales

Si bien excede los alcances de este curso, dejamos un chunk de código que puede resultar sumamente útil para crear un directorio de trabajo para un proyecto nuevo.

#install.packages(rstudioapi)
script.dir <- paste0(dirname(rstudioapi::getActiveDocumentContext()$path),"/")
bases.dir  <-  paste0(dirname(script.dir),"/Fuentes/")
#dir.create(bases.dir)
resultados.dir <- paste0(dirname(script.dir),"/Resultados/")
#dir.create(resultados.dir)

#chequeo
dir.exists(bases.dir)
dir.exists(resultados.dir)

La primera línea encuentra la carpeta donde esta guardado el script (si no esta guardado no funciona).
La segunda línea crea el nombre del directorio Fuentes La tercera línea (anulada) crea el directorio Fuentes La cuarta línea crea el nombre del directorio Resultados La quinta línea (anulada) crea el directorio Resultados

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 directorios
4. Definir funciones
5. Levantar archivos
   … procesamiento ….
   

14. 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 corchetes ###

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

Ejercicios para practicar

• Crear un OBJETO llamado OBJETO definido como el resultado de la suma: 5 + 6
• Crear un VECTOR VEC0 que contenga los números 1, 3, 4.
• Crear 3 vectores ( VEC1, VEC2, VEC3) que sean transformaciones del anterior
• Crear 3 vectores con la misma cantidad de elementos que VEC0, pero con variables string (texto) ( VEC4, VEC5, VEC6).
• Crear un dataframe DFRAME como combinación de todos los vectores creados previamente

• Crear una lista con cada uno de los elementos creados previamente

• Para todos los valores del vector VEC0, imprimir mediante un loop el doble de dichos valores
• Mediante un loop que itere sobre una de las columnas “string” del dataframe DFRAME, imprimir una variable que combine 3 columnas de dicho dataframe
• Reescribir el VEC1 del DATAFRAME para que sus elementos sean:
  • El Doble de VEC_0, cuando éste sea mayor a 2
  • Iguales a VEC_0, para el resto de los casos
• 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 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?
• Levantar del Excel llamado CANASTAS que se encuentra en la carpeta de Fuentes, la hoja “CBT” y definirla como HojaCBT. Pueden usar la función:
  • read.xlsx de la librería xlsx
  • read_excel de la librería readxl
• Levantar el mismo Excel, utilizando un Objeto que contenga el directorio del archivo a levantar.
  • Chequear con dir.exist() que lo creamos bien (¿no funcionó? pista: /\)

---

1. Más allá de los comandos elementales, comandos más sofisticados tienen muchas versiones, y algunas quedan en desuso en el tiempo.↩

2. existen ciertas excepciones con algunos paquetes más adelante.↩