Intro a R - Clase 1

Intro

¿Qué es R?

• Lenguaje de programación → análisis y visualización de datos
• Código abierto → esto significa que su instalación y uso sean GRATIS
• Comunidad abierta y colaborativa → hay un conjunto de funciones básicas al cual se le van agregando diferentes paquetes con funcionalidades específicas
• Paquetes instalables → siempre hay nuevas funcionalidades “customizables” para lo que queremos hacer. Los paquetes que veremos en este curso, tidyverse y ggplot son dos ejemplos de estos paquetes.

Pantalla de trabajo

- El trabajo en R se hace desde el panel de edición. - Los resultados aparecen en la consola. - Los gráficos aparecen en el panel de salida. - Para crear un script nuevo desde el cual trabajar, hago clic en File -> New File -> R Script.

Ayuda en R

El comando básico para averiguar qué hace una función o simplemente pedir ayuda es help("nombre de la función")

Mensajes de error

Cuando tipeamos mal algo, cuando intentamos usar una función en un objeto que no corresponde, o, en general, nos la mandamos, R va a imprimir un mensaje de error en la consola. Esto no es lo mismo que un warning, que nos aparece también en la consola en el mismo color. Este último es nada más una advertencia de que el comando que emitimos operó de una determinada manera que quizás no nos guste, pero en general no significa que algo haya salido mal.

Cuando hay un mensaje de error, lo que queríamos hacer no salió. Esto es lo más normal del mundo, por lo que, además de frustrarnos y entrar en pánico, como regla general lo que hay que hacer es pegar ese mensaje de error en Google y ver los primeros resultados. 99.9% de las veces alguien más ya tuvo ese error y lo subió a Stack Overflow o alguna otra plataforma de respuestas, y allí vamos a encontrar la forma de solucionar el problema.

Objetos de R base

Los Objetos/Elementos constituyen la categoría escencial de R. De hecho, todo en R es un objeto, y se almacena con un nombre específico que no debe poseer espacios. Un número, un vector, una función, la progresión de letras del abecedario, una base de datos, un gráfico, constituyen para R objetos de distinto tipo. Los objetos que vamos creando a medida que trabajamos pueden visualizarse en la panel derecho superior de la pantalla (“Environment”).

Los nombres de los objetos deben empezar con una letra y únicamente pueden contener letras, números, _ y .. Por convención, se recomienda hacer nombres descriptivos y utilizar el guión bajo como espacio (por ejemplo, si quiero crear una columna de nombres y apellidos la puedo nombrar nombre_apellido).

Valores

La unidad mínima que pueden contener estos objetos son los valores. Existen cuatro tipos:

• character: valores alfanuméricos, es decir, letras, números y signos mezclados.

• numeric: valores numéricos, incluye decimales.

• integer: números enteros, no incluye decimales.

• logical: valores lógicos, un TRUE o FALSE

Para guardar un objeto en R se usa el símbolo = o una flecha <-. Por convención, se usa la flecha. A la izquierda siempre va el nombre que le vamos a asignar al objeto, y a la derecha, el valor.

> objeto_1 <- 55
> objeto_2 = 7

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.

Si quiero ver el contenido de un objeto, puedo imprimirlo en el script llamando al nombre del objeto:

> objeto_1
## [1] 55

Los objetos pueden sobreescribirse. Esto quiere decir que si vuelvo a generar un objeto con el mismo nombre que tiene otro ya existente, el último reemplaza al primero.

Vectores

R puede almacenar un conjunto de valores como un mismo objeto en un elemento llamado vector.

> vector_1 <- c(55, 65, 75, 85, 95, 105) #Este sería un vector numérico
> vector_2 <- c("Uno", "Dos", "Tres", "Cuatro", "Cinco") #Y este un vector de texto

Cuandose mezclan diferentes objetos en un vector R hace uso de la “coerción”: se fuerza a los objetos a transformarse en una misma clase

> y<-c(1.2,"a") 
> y
## [1] "1.2" "a"
> x<-c(FALSE, 2)
> x
## [1] 0 2

Puede aplicarse de forma explícita la coercion; se usan las funciones as.[class]. Esta coercion puede aplicarse a otros objetos, no solo a vectores

> x<-0:6
> as.character(x)
## [1] "0" "1" "2" "3" "4" "5" "6"

Factores

Para almacenar valores categóricos se usa el objeto factor. Funcionan como un integrer con una etiqueta asociada. Se puede generar factors ordenados con el argumento levels. Por default, R usa el orden numérico ascendente u orden alfabético dependiendo el tipo de valor.

> cat_ocup<- factor(c("Ocup","Ocup","Desoc","Ocup"
+       ,"Inact"))
> cat_ocup
## [1] Ocup  Ocup  Desoc Ocup  Inact
## Levels: Desoc Inact Ocup
> 
> cat_ocup <- factor(c("Ocup","Ocup","Desoc","Ocup","Inact"),
+             levels=c("Inact", "Desoc", "Ocup"))
> cat_ocup
## [1] Ocup  Ocup  Desoc Ocup  Inact
## Levels: Inact Desoc Ocup

Listas

Las listas son una clase especial de vector: pueden contener elementos de cualquier tipo en su interior.

> l<-list(1,"a",TRUE, 4.6)
> l
## [[1]]
## [1] 1
## 
## [[2]]
## [1] "a"
## 
## [[3]]
## [1] TRUE
## 
## [[4]]
## [1] 4.6

Por ejemplo, puedo llenar una lista de vectores:

> l <- list(c("A", "B", "C", "D"), c(1:15))
> l
## [[1]]
## [1] "A" "B" "C" "D"
## 
## [[2]]
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

Dataframes

Finalmente, están los dataframes. Son lo más parecido a lo que entendemos por base de datos. Cada columna es una variable, y cada fila es una observación. Para R son un tipo especial de vector, en la cual cada elemento del vector tiene la misma longitud (length()). Cada observación (fila) está compuesta por datos que pueden ser de distinto tipo.

Este objeto es central en el proceso de trabajo, ya que es la estructura más usada para realizar análisis de datos, y suele ser la forma en que se cargan datos externos para trabajar en el ambiente de R, y en que se exportan los resultados de nuestros trabajo.

• Tienen un atributo especial: row.names, que vendría a ser como el identificador de cada fila.

• Pueden ser transformados en matrices usando data.matrix()

La función básica para crear un dataframe a partir de dos vectores es data.frame(). Creemos uno a partir de tres vectores:

> ### Creo los vectores 
> nombres <- c("Natalia Pérez", "Débora Fernández", "Julián López", "Eduardo Gómez", "Ana Pérez")
> edades <- c(34, 65, 51, 36, 41)
> 
> #Creamos el dataframe y lo guardamos en el objeto "data"
> data <- data.frame(nombres, edades, cat_ocup)
> 
> data
##            nombres edades cat_ocup
## 1    Natalia Pérez     34     Ocup
## 2 Débora Fernández     65     Ocup
## 3     Julián López     51    Desoc
## 4    Eduardo Gómez     36     Ocup
## 5        Ana Pérez     41    Inact

Algunas funciones útiles para trabajar con dataframes son:

• dim(): indica la cantidad de filas y columnas del dataframe.

> dim(data)
## [1] 5 3

• str(): muestra la estructura del dataframe. Los nombres de las columnas, la cantidad de observaciones, y las primeras observaciones de cada columna.

> str(data)
## 'data.frame':    5 obs. of  3 variables:
##  $ nombres : chr  "Natalia Pérez" "Débora Fernández" "Julián López" "Eduardo Gómez" ...
##  $ edades  : num  34 65 51 36 41
##  $ cat_ocup: Factor w/ 3 levels "Inact","Desoc",..: 3 3 2 3 1

• summary(): da un resumen en forma de estadísticas descriptivas para las variables numéricas (cuartiles y mediana) y un vistazo a las categorías más representadas par los factores

> summary(data)
##    nombres              edades      cat_ocup
##  Length:5           Min.   :34.0   Inact:1  
##  Class :character   1st Qu.:36.0   Desoc:1  
##  Mode  :character   Median :41.0   Ocup :3  
##                     Mean   :45.4            
##                     3rd Qu.:51.0            
##                     Max.   :65.0

• head(): nos muestra las primeras 10 observaciones de la base.

> head(data)
##            nombres edades cat_ocup
## 1    Natalia Pérez     34     Ocup
## 2 Débora Fernández     65     Ocup
## 3     Julián López     51    Desoc
## 4    Eduardo Gómez     36     Ocup
## 5        Ana Pérez     41    Inact

Valores nulos

Los NA’s o valores nulos son, justamente, valores que no existen o aparecen. Estos pueden resultar algo problemáticos a la hora de trabajar, por lo que es importante identificarlos y decidir qué hacer con ellos. La función is.na()nos devuelve un vector logical indicando qué valores son NA.

> na_ejemplo <- c(1,2,NA,4,NA)
> is.na(na_ejemplo)
## [1] FALSE FALSE  TRUE FALSE  TRUE

Si hay varias columnas con NA´s, entonces puede usarse complete.cases()

> x <- c(1, 2, NA, 4) 
> y <- c(NA, "a", NA, "n") 
> m <- cbind(x, y) 
> m1 <- m[complete.cases(m), ] 
> m1 
##      x   y  
## [1,] "2" "a"
## [2,] "4" "n"

Operaciones con los objetos

Puedo hacer múltiples operaciones con los objetos a través de operadores. Estos pueden ser arimétricos, por ejemplo:

> objeto_1/5
## [1] 11
> objeto_1+objeto_2
## [1] 62

Los operadores también pueden aplicarse sobre vectores de la misma forma:

> n <- 1:10
> n+5
##  [1]  6  7  8  9 10 11 12 13 14 15

Pero no sobre listas, ya que un operador arimétrico sólo se puede aplicar en un subconjunto numérico.

Los operadores también pueden pueden ser relacionales, para hacer comparaciones entre valores. Éstos son:

• < o >, para indicar si es menor a o mayor a y <= o >= para indicar si es mayor o igual/menor o igual.

> objeto_1 < objeto_2
## [1] FALSE
> 
> objeto_1 > objeto_2
## [1] TRUE

• == para indicar si un valor es igual a otro y != para indicar si un valor no es igual a otro.

> "Ocupado" != "Desocupado"
## [1] TRUE
> 
> "Ocupado" == "Desocupado"
## [1] FALSE

• ! como negación.

> !is.na("A")
## [1] TRUE
> 
> !is.na(NA)
## [1] FALSE

O lógicos, los cuales son para hacer expresiones booleanas. Esto quiere decir que se usan para hacer combinaciones y búsquedas más complejas. Los principales son & para hacer búsquedas de AND, o | para hacer búsquedas OR.

> x <- c(TRUE,FALSE,0,6)
> y <- c(FALSE,TRUE,FALSE,TRUE)
> x&y
## [1] FALSE FALSE FALSE  TRUE
> x|y
## [1]  TRUE  TRUE FALSE  TRUE

Navegando por los objetos

Ahora bien, ¿de qué sirve almacenar los valores en objetos como vectores, listas o dataframes? ¿Cómo podemos acceder a estos valores? ¿Cómo podemos aplicar transformaciones a un subconjunto de estos objetos? A estas operaciones se las llama subsetting o slicing.

La forma para navegar a través de los valores de un vector, una lista o un dataframe es a través de corchetes ([]).

Por ejemplo, supongamos que queremos tomar el segundo valor del vector cat_ocup con el que veníamos trabajando:

> cat_ocup[2]
## [1] Ocup
## Levels: Inact Desoc Ocup

También podemos usar los corchetes para modificar el valor en el vector:

> cat_ocup[2] <- "Inact"
> 
> cat_ocup
## [1] Ocup  Inact Desoc Ocup  Inact
## Levels: Inact Desoc Ocup

En el caso de una lista, tenemos que usar un doble corchete [[]] para acceder a sus valores. Por ejemplo:

> l[[1]]
## [1] "A" "B" "C" "D"

Y podemos acceder al valor que queremos dentro de ese nivel de la lista con un corchete simple.

> l[[1]][2]
## [1] "B"

En un dataframe, también podemos seleccionar un valor entre corchetes usando el orden [fila, columna]. Volvamos a nuestro ejemplo data:

> data
##            nombres edades cat_ocup
## 1    Natalia Pérez     34     Ocup
## 2 Débora Fernández     65     Ocup
## 3     Julián López     51    Desoc
## 4    Eduardo Gómez     36     Ocup
## 5        Ana Pérez     41    Inact
> data[4, 1] #Extraemos el nombre del cuarto registro
## [1] "Eduardo Gómez"

También podemos seleccionar varios valores de una columna con el comando ::

> data[2:4, 1]
## [1] "Débora Fernández" "Julián López"     "Eduardo Gómez"

Y podemos consultarle a R los valores completos de una columna con el comando $:

> data$edades
## [1] 34 65 51 36 41

Acorde a lo visto anteriormente, el acceso a los dataframes mediante [ ] puede utilizarse también para realizar filtros con operadores. Por ejemplo, puedo utilizar los [ ] para obtener del dataframe Datos unicamente los registros de desocupados:

> data[data$cat_ocup=="Desoc", ]
##        nombres edades cat_ocup
## 3 Julián López     51    Desoc

La lógica del paso anterior sería: Accedo al dataframe data, pidiendo únicamente conservar las filas (por eso la condición se ubica a la izquierda de la ,) que cumplan el requisito de pertenecer a la categoría Desocupados de la variable cat_ocup.

Aún más, podría aplicar el filtro y al mismo tiempo identificar una variable de interés. Por ejemplo, supongamos que quiero solo los nombres de los desocupados en el dataframe.

> data$nombres[data$cat_ocup=="Desoc"]
## [1] "Julián López"

Funciones

Crear funciones

La función es una forma de encapsular una serie de operaciones que de otra manera nos llevarían más pasos y tiempo. Una función tiene un nombre y coloca entre paréntesis () los argumentos. Se pueden almacenar como objetos.

> fun<-function(argumentos){
+   #[se hace algún cómputo]
+ }

• Las funciones tienen un input (argumentos) y devuelven un output (valor)
  • Argumentos formales: los que están incluidos en la definición de la función
  • La función formal() devuelve los argumentos formales de una función
  • No todas las funciones en R usan argumentos formales
  • Los argumentos pueden estar “missing” o tener valores asignados por defecto
  • Para que una función devuelva un valor, debo almacenarlo en la misma e indicarlo con el comando return()

Por ejemplo, si quiero crear una función que multiplique por 10 cualquier vector, hago lo siguiente:

> funcion_multiplico <- function(vector){
+         resultado <- vector*10
+         return(resultado)
+ }
> 
> funcion_multiplico(1:10)
##  [1]  10  20  30  40  50  60  70  80  90 100

Algunas funciones tienen parámetros, los cuales sirven para especificar una operación que realiza la función. Por ejemplo, la función paste que viene en R base sirve para concatenar valores de texto con un separador. El argumento sep funciona como parámetro:

> paste("Estoy", "haciendo", "un", "ejemplo", sep="-")
## [1] "Estoy-haciendo-un-ejemplo"

Funciones útiles

Ya que estamos, podemos ver un popurrí de funciones de R base que resultan bastante útiles:

• mean(): calcula la media arimétrica de un vector.

• median(): devuelve la mediana de un vector.

• quantile(): calcula los casos equivalentes a diferentes proporciones de la distribución en un vector. Con el argumento prob se indica en formato vector los cuantiles a calcular. Por ejemplo, si quisiese calcular los rangos intercuartiles indicaría: prob = c(0.25, 0.5, 0.75).

• table(): devuelve una tabla de frecuencias de un vector de texto o factor.

-prop.table(): devuelve una tabla de frecuencias relativas en proporción. Para obtener los porcentajes, hago: prop.table(vector)*100

-sum(): realiza la suma de todos los valores de un vector.

-round(): hace un redondeo de los valores.

Borrar objetos

Finalmente, para borrar los objetos de R podemos usar la función rm():

> rm(data)

Si quiero borrar múltiples elementos a la vez, tengo que encapsularlos en una lista dentro de la función:

> rm(objeto_1, objeto_2)

¡Terminamos! Ahora, vamos a la parte práctica.