R: Técnicas y herramientas para investigadores

Universidad de Salamanca

Introducción a R y R Studio

Instalación de R y RStudio

Una de las grandes ventajas de R es que es software libre, por lo que podemos tener siempre instalada la última versión. Se puede instalar la última versión a partir del repositorio cran utilizando las opciones por defecto.

Página de acceso a cran con las opciones de descarga al comienzo.

Por su parte, RStudio puede también instalarse de manera gratuita desde la página de RStudio. Hay que instalarlo después de tener instalado R. Con las opciones por defecto, identificará la versión de R que acabamos de instalar y ya podremos trabajar a partir del icono

Icono de RStudio

El entorno de RStudio

https://www.analyticsvidhya.com/blog/2016/02/complete-tutorial-learn-data-science-scratch/

El entorno RStudio está definido por una serie de ventanas que permiten realizar distintas tareas. Las más importantes son:

• Consola R: Esta ventana interactiva permite escribir directamente código R, y muestra también la salida del código que ejecuta. El código escrito en la consola R no se guarda directamente, aunque se puede acceder a las ordenes anteriores con la flecha hacia arriba.
• Entorno R (environment): En este espacio se muestra el conjunto de objetos que R tiene cargados en memoria. Esto incluye conjuntos de datos, variables, vectores, funciones, etc. También hay otras solapas que permiten acceder entre otros, a la historia: el código ejecutado recientemente.
• Salida gráfica: Este espacio tiene varias solapas. La solapa plots muestra los gráficos creados con R. Hay otras solapas: files permite explorar los archivos en la carpeta de trabajo, incluido cambiar ésta. La solapa Packages permite comprobar qué paquetes de R están instalados, cargarlos e instalar nuevos. La pestaña help permite acceder a la ayuda de R integrada. Por último la pestaña viewer contiene los resultados producidos por R que corresponden a otro tipo de objetos, como ficheros html.
• editor R (Script): Cuando abrimos por primera vez esta ventana no aparece, pero luego será fundamental. Como su nombre sugiere, aquí tienes espacio para editar código. Los ficheros de código de R son siempre ficheros de texto, que pueden tener la extensión .r (sólo código) o .rmd (código combinado con generación de documentos). Para ejecutar códigos seleccionamos las líneas de código y hacemos Ctrl + Enter o hacemos clic en el botón run. En este espacio también se abren pestañas para visualizar objetos de R cuando hacemos clic en la ventana del entorno R.

Instalación de paquetes, ayuda, y funciones en R

Aunque el llamado R base contiene las definiciones básicas del lenguaje R así como numerosas funciones, la potencia de R está en los paquetes. Un paquete de R es un conjunto de funciones y/o de objetos de datos que responden a un propósito concreto. Los más de 11000 paquetes oficiales están incluidos en el repositorio de cran

Página de paquetes en cran

Los paquetes de cran los contribuyen de manera libre sus autores. Son oficiales en la medida en que han superado una serie de pruebas y tienen documentación que sigue el formato oficial. Para poder trabajar con ellos tenemos que tenerlos descargados en el ordenador, en una carpeta concreta que en windows suele ser Mis documentos/R/win-library/3.4 (o la versión correspondiente). Podemos instalar paquetes de varias formas: en la pestaña packages con el icono install, en el menu Tools > Install packages..., o con la función install.packages. Podemos utilizar install.packages como un primer ejemplo de función en R. Las funciones ordenan a R hacer algo. En el caso de install.packages, instalar el paquete en la carpeta que corresponda (o en la que especifiquemos). Para ver la ayuda podemos utilizar ? install.packages o help(install.packages)

? install.packages

Ayuda de install.packages()

Las funciones de R son un verbo seguido de una serie de argumentos que pueden identificarse por su nombre o por su posición. No hace falta escribir el nombre completo del argumento si no es ambiguo. En el caso de install.packages el primer argumento, y básico, es pkgs, el paquete o paquetes a instalar. Por ejemplo, para instalar el paquete `MicroDatosEs" que permite importar microdatos del INE, haríamos

install.packages("MicroDatosEs")

Si no hemos especificado de qué repositorio queremos descargar los paquetes nos lo preguntará. No es mala opción la primera que se ofrece, descargar de la nube.

Muchos de los paquetes incorporan viñetas: ejemplos breves (y no tan breves) reproducibles que nos explican cómo funciona el paquete. En este enlace tenemos la página en cran de tidyr.

Página en cran del paquete tidyr

podemos seguir el enlace a la viñeta y aprender a utilizar el paquete. Todo siempre empieza por cargar el paquete. Esto lo hacemos con library(paquete).

Nuestra configuración, install.views y install_github

Los paquetes en R se pueden ir instalando según se necesitan. Para ello hay que estar atentos a los posibles mensajes de error en la consola que nos digan que no se localiza determinado paquete. En ese caso la primera respuesta es instalarlo con install.packages.

Otra opción es preinstalar los paquetes principales. Esto es lo que hemos tenido que hacer en las aulas de informática al estar los ordenadores congelados. Si queréis instalar en vuestro ordenador los mismos paquetes que aquí hay dos formas de hacerlo:

• Los paquetes preinstalados de la versión de windows de R 3.4.2 están disponibles en este fichero rar al que tenéis acceso si accedéis desde vuestra cuenta usal. Debéis descomprimirlo en la carpeta documentos\R\win-library de vuestro ordenador (permitiendo que el RAR descomprima los paquetes como carpetas en el directorio 3.4).

• Abrir este script de R, al que también hace falta acceder desde la cuenta usal, y ejecutarlo en R. La forma más cómoda es abrilo en Rstudio con File> Open file..., que abre en la ventana del editor, y ejecutar seleccionando las partes que queráis del fichero y dando al icono Run (o Ctrl+ENTER).

El fichero es un código de R particularmente sencillo. Sólo contiene:

• Comentarios: Las lineas de comentario, que R no interpreta, se distinguen por empezar por la almohadilla #
• install.packages. La opción dep identifica el argumento dependencies.
• La función c. Es la función más sencilla y útil de R. Procede de colección o conjunto, y sencillamente junta objetos. c("paquete1","paquete2") como argumento en install.packages hace que instalemos los dos paquetes.
• library: Para cargar paquetes. En nuestro caso, el paquete ctv que permite instalar paquetes por temas desde cran con CRAN task views.
• Existe también la posibilidad de instalar paquetes no oficiales desde un repositorio github. De hecho, la mayor parte de los paquetes oficiales se van desarrollando ahí, y muchas veces es posible instalar la versión de desarrollo desde github. Para ello hace falta tener instalado el paquete devtools, que contiene la función install.github.
• Existe una forma de utilizar funciones de un paquete sin necesidad de cargar el paquete. En este caso hay que designar a la función por su apellido (el paquete) y su nombre. Esto se hace como paquete::funcion(). Por ejemplo, el paquete “caRtociudad” no está en cran, y permite pedir información geográfica española al servidor de cartociudad. El paquete está desarrollado en github, y si ya tenemos instalado devtools lo podemos descargar con

devtools::install_github("cjgb/caRtociudad")

Si instaláis los paquetes desde R, necesitáis acceso a internet y paciencia.

El operador después %>%

El operador entonces o después, del paquete magrittr. En RStudio, Ctrl+Mayús+M

Pocas veces algo tan pequeño puede suponer un cambio tan grande. El operador después ha tenido consecuencias revolucionarias sobre cómo se escribe código en R al hacer mucho más sencillo especificar cadenas de funciones. Una de las limitaciones que tenía R era que el código se hacía muy dificil al tener funciones que llamaban a funciones que lllamaban a funciones. Las posibilidades eran dos: código ilegible lleno de paréntesis que se abren y cierran sin saber a qué corresponden, o asignaciones de resultados intermedios que no tenía interés guardar. El pequeño operador %>% acaba con esto con una idea muy sencilla: En vez de escribir f(x,a) escribimos x %>% f(a), que se puede leer: coge el objeto x y después aplícale la función f con el argumento a. Podemos ver en esta tabla la comparación de cómo se escribirían ciertos códigos con el sistema tradicional y con el operador después:

Estándar	Con operador %>%
f(x,a)	x %>% f(a)
g(f(x,a),b)	x %>% f(a) %>% g(b)
h(g(f(x,a),b))	x %>% f(a) %>% g(b) %>% h()
h(b,f(x,a))	x %>% f(a) %>% h(b, . )

¿Por qué un cambio tan trivial tiene unos efectos tan grandes? Porque cambia los incentivos a cómo diseñar código. Antes del operador después los paquetes tendían a crear funciones grandes que permitían poco control al analista. Esto es lo que ocurre con buena parte de los programas estadísticos alternativos como Stata o SPSS. Frente a este modelo, ha surgido el tidyverse, compuesto por paquetes que comparten la misma filosofía: definir funciones específicas que hacen una tarea pequeña pero muy bien. La potencia está en la concatenación de esas tareas relativamente simples. Estos principios los puedes ver expuestos en el tidy tools manifesto de Hadley Wickham.

Es cierto que esta estrategia tiene también sus problemas. En concreto, es necesario ampliar el vocabulario que uno usa. El problema es que olvidamos el nombre de esa función, o de ese paquete. No voy a negar que esto es un problema, pero también existen posibles remedios: - Algunos paquetes, como stringr para manipulación de cadenas de texto, hacen que todas las funciones del paquete empiecen igual: str_xxxx. Esto es muy util en Rstudio porque cuando empezamos a escribir el nombre de la función nos sugiere las posibles terminaciones, y si damos a F1 sobre una función sugerida nos abre la ayuda. - Rstudio ha introducido pequeñas aplicaciones interactivas llamadas addins. Estas aplicaciones nos ayudan a seleccionar la función adecuada para los paquetes más importantes como dplyr, tidyr o ggplot2. Las addins se activan a partir de la pestaña específica de la segunda línea de Rstudio. Ya veremos algunas aplicaciones. También existen gui alternativos, como Rcmdr, que funcionan por menús y pueden ayudar a no tener que memorizar tantas funciones.

¿Cómo funciona R? Objetos y funciones

Hemos visto que R es un lenguaje, que podemos asimilar a un lenguaje natural: las funciones hacen el papel de los verbos, dan ordenes respecto a qué hacer. Los argumentos que toman las funciones pueden ser funciones o cualquier otro objeto de R. Vamos a ver que en R hay muchas clases de objetos. Los más sencillos son los vectores (no hay objetos “elementales”. que serían vectores de tamaño 1). Las funciones también pueden escribirse de dos formas: en notación funcional como f(a,b) o utilizando operadores, replicando el lenguaje natural y las matemáticas básicas, como 2+2, 10/5 o a %>% f(b). Veámos que funciona:

2+2

## [1] 4

10/5

## [1] 2

paste("2+2 es igual a",2+2)

## [1] "2+2 es igual a 4"

La función paste junta cadenas alfanuméricas separándolas por espacios (o el carácter especficado como argumento sep).

Para utilizar el operador %>% tenemos que cargar primero un paquete que lo contenga (magrittr, dplyr o tidyverse). Vamos a cargar tidyverse que es un paquete de paquetes: carga los paquetes básicos para análisis de datos, incluido dplyr

library(tidyverse)
"2+2 es igual a" %>% paste(2+2)

## [1] "2+2 es igual a 4"

Para guardar un objeto de R hay que asignarle un nombre. Hay varios operadores para la asignación, =, <- y <-. Se pueden concatenar varias asignaciones con ;.

x = 4; y <- c(2,3); x*y -> z
z

## [1]  8 12

Al escribir el nombre del objeto y dar ENTER, se muestra el objeto. Realmente, se ejecuta la función print (z equivale a print(z)).

Los vectores son los objetos elementales más sencillos en R. Pueden ser de varios tipos:

Variable de tipo	Designación
Entero	integer
Real	double o integer
Lógico	logical
Alfanumérico	character
Complejo	complex

Para todos los tipos existen funciones para comprobar si la variable pertenece a ese tipo con el prefijo is. o para convertir de tipos con as. (también hay otras funciones muy similares pero que funcionan mejor en casos límites definidas en el tidyverse: is_ y as_):

is.integer(3:5)

## [1] TRUE

as.character(3:5)

## [1] "3" "4" "5"

Para seleccionar elementos de un vector se utiliza los corchetes. El operador : define una secuencia de enteros, y la función seq una secuencia de valores (podéis estudiar los argumentos con ? seq o help(seq))

y[1]

## [1] 2

letters[3:6]

## [1] "c" "d" "e" "f"

letters[seq(2,20,by=2)]

##  [1] "b" "d" "f" "h" "j" "l" "n" "p" "r" "t"

donde letters es la constante predefinida que contiene las letras en el idioma por defecto.

Por último, tenemos los objetos complejos, que se componen de objetos más sencillos. Entre ellos están las matrices (matrix) y los arreglos (array), objetos con dos o más dimensiones:

x = cbind(1:3,8:10) # cbind: Pega columnas
x

##      [,1] [,2]
## [1,]    1    8
## [2,]    2    9
## [3,]    3   10

dim(x)

## [1] 3 2

class(x)

## [1] "matrix"

x[,1]

## [1] 1 2 3

x[2:3,]

##      [,1] [,2]
## [1,]    2    9
## [2,]    3   10

Por último, los dos tipos específicos de R y muy útiles, son las listas (list) y los objetos de datos (data.frame), del que se derivan las tiablas (tibble). Las listas son colecciones de objetos de cualquier tipo que se diferencian por su número de orden y/o por su nombre. Se puede acceder directamente por nombre o por índice:

y=list(matriz=x,cadena=letters,numeros=1:15)
class(y)

## [1] "list"

y$numeros

##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15

y["cadena"]

## $cadena
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q"
## [18] "r" "s" "t" "u" "v" "w" "x" "y" "z"

y[[1]]

##      [,1] [,2]
## [1,]    1    8
## [2,]    2    9
## [3,]    3   10

Podéis también comprobar cómo han ido cambiando las cosas en el cuadro Environment de Rstudio. Haciendo clic en la flecha adjunta al objeto, podéis desplegar los contenidos de éste.

Por último, los data,frame y las tiablas son “matrices” definidas por columnas, donde cada columna es una variable que puede ser de tipo diferente. Se pueden tratar tanto como si fuesen matrices o como si fuesen listas, además de las funciones específicas para ellas que vamos a estudiar en el tidyverse.

alfabeto=data.frame(orden=seq_along(letters),letra=letters,vocal=letters %in% c("a","e","i","o","u"))
alfabeto[alfabeto$vocal,]

##    orden letra vocal
## 1      1     a  TRUE
## 5      5     e  TRUE
## 9      9     i  TRUE
## 15    15     o  TRUE
## 21    21     u  TRUE

dim(alfabeto)

## [1] 26  3

alfabeto %>% as_tibble %>% class

## [1] "tbl_df"     "tbl"        "data.frame"

Tenéis más sobre conceptos básicos de R base en la Introduction to R y en Programación en R

Proyectos de Rstudio

La mejor manera de trabajar en Rstudio es creando proyectos para cada tarea. Rstudio crea un fichero .Rproj que inicia Rstudio con esa carpeta (o la definida en el proyecto) como carpeta por defecto, con los ficheros ya cargados, y, si se desea, con los datos ya cargados. Tenemos en forma comprimida un proyecto para seguir trabajando que incluye una introducción a la generación de documentos reproducibles con knitr en el formato rmarkdown, y un ejemplo completo de aplicación de R, con el cálculo de la brecha de género por CCAA en Pisa 2015.

Podéis descargar nuestro proyecto 1 en este enlace. Copiarlo en el escritorio y descomprimirlo, y abrir el fichero .Rproj. También se puede crear nuevos proyectos, ver los proyectos recientes, y cargarlos en el menú File.