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
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
Con R base nos referimos a los comandos básicos que vienen incorporados en el R, sin necesidad de cargar librerías.
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.
#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
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
[]
se utilizan para acceder a un objeto:
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)
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
Los datos tienen distintos tipos:
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"
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"
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"
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
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
100.00 | Oct-16 | Privado_Registrado | ||
100.00 | Oct-16 | Público | ||
100.00 | Oct-16 | Privado_No_Registrado | ||
101.80 | Nov-16 | Privado_Registrado | ||
101.20 | Nov-16 | Público | ||
100.73 | Nov-16 | Privado_No_Registrado | ||
102.90 | Dic-16 | Privado_Registrado | ||
102.40 | Dic-16 | Público | ||
103.20 | Dic-16 | Privado_No_Registrado |
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.
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
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
100.00 | Oct-16 | Privado_Registrado | ||
100.00 | Oct-16 | Público | ||
100.00 | Oct-16 | Privado_No_Registrado | ||
101.80 | Nov-16 | Privado_Registrado | ||
101.20 | Nov-16 | Público | ||
100.73 | Nov-16 | Privado_No_Registrado | ||
102.90 | Dic-16 | Privado_Registrado | ||
102.40 | Dic-16 | Público | ||
103.20 | Dic-16 | Privado_No_Registrado |
[[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
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:
También se puede tomar una lista de valores cualesquiera. Por ejemplo reutilizar datos de un dataframe:
Datos
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
100.00 | Oct-16 | Privado_Registrado | ||
100.00 | Oct-16 | Público | ||
100.00 | Oct-16 | Privado_No_Registrado | ||
101.80 | Nov-16 | Privado_Registrado | ||
101.20 | Nov-16 | Público | ||
100.73 | Nov-16 | Privado_No_Registrado | ||
102.90 | Dic-16 | Privado_Registrado | ||
102.40 | Dic-16 | Público | ||
103.20 | Dic-16 | Privado_No_Registrado |
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,])
}
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
1 | 100.0 | Oct-16 | Privado_Registrado | |
4 | 101.8 | Nov-16 | Privado_Registrado | |
7 | 102.9 | Dic-16 | Privado_Registrado |
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
2 | 100.0 | Oct-16 | Público | |
5 | 101.2 | Nov-16 | Público | |
8 | 102.4 | Dic-16 | Público |
INDICE <dbl> | FECHA <fctr> | GRUPO <fctr> | ||
---|---|---|---|---|
3 | 100.00 | Oct-16 | Privado_No_Registrado | |
6 | 100.73 | Nov-16 | Privado_No_Registrado | |
9 | 103.20 | Dic-16 | Privado_No_Registrado |
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)
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"
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:
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
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:
# 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
USA <dbl> | Mundo <dbl> | |||
---|---|---|---|---|
Batman Begins | 207 | 167 | ||
Dark Knight | 535 | 470 | ||
Dark Knight Rises | 448 | 636 |
# ¿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
R tiene formatos de archivos propios:
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.
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)
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:
,
, tab, ;
)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)
CODUSU <fctr> | ANO4 <int> | TRIMESTRE <int> | NRO_HOGAR <int> | COMPONENTE <int> | H15 <int> | REGION <int> | ||
---|---|---|---|---|---|---|---|---|
1 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 4 | 1 | 43 | |
2 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 5 | 1 | 43 | |
3 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 6 | 1 | 43 | |
4 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 7 | 1 | 43 | |
5 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 8 | 0 | 43 | |
6 | TQRMNOQURHKOMLCDEFIAH00469284 | 2017 | 1 | 1 | 9 | 0 | 43 |
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
x <dbl> | y <dbl> | |||
---|---|---|---|---|
1 | 11 | |||
2 | 12 | |||
3 | 13 | |||
4 | 14 | |||
5 | 15 | |||
6 | 16 | |||
7 | 17 | |||
8 | 18 | |||
9 | 19 | |||
10 | 20 |
Podemos utilizar la librería haven, y los comandos:
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”.
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
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
Por último, es aconsejable mantener en todos los script una misma estructura del tipo:
rm(list=ls())
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 ###
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
stack overflow conviene llegar desde google
Crear una lista con cada uno de los elementos creados previamente
Crear una función que devuelva la sumatoria de los números enteros comprendidos entre 1 y un parámetro x a definir
dir.exist()
que lo creamos bien (¿no funcionó? pista: /\)