Introducción

En el curso aprenderemos R utilizando las técnicas que lo han revolucionado en los últimos años y que permiten de manera relativamente sencilla efectuar análisis muy sofisticados.

Los grandes cambios que han dado la vuelta a cómo se trabaja en R en los últimos años son:

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.uv.es/vcoll/primeros-pasos.html

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

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

Aunque la versión “de fábrica” 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 16000 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/4.0 (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 y 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 e 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. Para instalar la gran mayoría de paquetes que vamos a utilizar a lo largo del curso podéis copiar el código R que aparece abajo en la consola de R y ejecutarlo [Requiere acceso, a ser posible rápido, a internet]

### Instalar paquetes de R en casa

# Al instalar el primer paquete preguntará 
#   qué repositorio utilizar.
# Seleccionar la opción primera de sitio desde
#   donde instalar ("cloud")

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

# Para poder compilar (opcional)
# Rtools: https://cran.r-project.org/bin/windows/Rtools/

# Paquetes:   (decir "n" cuando pregunta si queremos compilar)
install.packages("devtools",dep=TRUE)
install.packages("tidyverse",dep=TRUE)
install.packages(c("tigerstats","tidymodels"),dep=TRUE)
install.packages(c("ggedit","ggeffects","ggforce","ggformula","ggfortify","ggiraph","ggiraphExtra","ggplotAssist","ggplotgui","ggpubr","ggExtra"),dep=TRUE)
install.packages(c("knitr","kableExtra","tinytex","RefManageR","bookdown","bookdownplus"),dep=TRUE)

install.packages("ctv")
library("ctv")
install.views("Econometrics")
install.views("OfficialStatistics",coreOnly=TRUE)
install.views("MachineLearning",coreOnly=TRUE)
install.packages(c("olsrr","ggResidpanel","qqplotr","gratia","esquiser", "interactions","blorr","modelsummary","panelr"))
install.packages(c("performance","predict_3d","plotmo","plotres"),dependencies=TRUE)
install.packages(c("memisc","mosaicCalc","intsvy"),dependencies=TRUE)
install.packages(c("stargazer","condformat","flextable","RJSplot","lemon","patchwork"),dependencies=TRUE)
install.packages("robust",dependencies=TRUE)
install.packages("pdfetch",dependencies=TRUE)
install.packages("pxR",dependencies=TRUE)
install.packages(c("OECD","ecb"),dependencies=TRUE)
install.packages(c("countrycode","directlabels","visreg","dotwhisker"),dep=TRUE)
install.packages(c("eurostat","wbstats"),dependencies=TRUE)
install.packages(c("Rcmdr","DALEX","mlr","auditor","EffectStars"), dependencies=TRUE)
install.packages("RcmdrPlugin.HH",dependencies=TRUE)
install.packages("RcmdrPlugin.KMggplot2",dependencies=TRUE)
install.packages("RcmdrPlugin.plotBy",dependencies=TRUE)
install.packages("RcmdrPlugin.TeachingDemos",dependencies=TRUE)
install.packages("RcmdrPlugin.UCA",dependencies=TRUE)
install.packages("Sleuth3")
install.packages("ISLR")
install.packages("swirl",dependencies=TRUE)
install.packages("faraway")
install.packages("ISwR")
install.packages(c("alr4","pder"))
install.packages(c("ggrepel","ggalt","ggpmisc","GGally","ggridges","cowplot","qqplotr"))
install.packages(c("MicroDatosEs","fst","jtools","mixlm","DAAG"))
install.packages("addinslist")
install.packages(c("addinslist","modelbased","effectsize"))
install.packages(c("orcutt","ivreg","insight","ggstatsplot"))
install.packages("fpp3",dependencies=TRUE)
devtools::install_github("ProjectMOSAIC/mosaicModel")
remotes::install_github("gpw13/goalie")

## Para installar latex
# Sirve para poder generar pdfs desde RStudio
tinytex::install_tinytex()
tinytex:::is_tinytex()

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

devtools::install_github("rOpenSpain/caRtociudad")

El operador después |>

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,y=a)) x |> f(a) |> h(b,y=_)

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

%>% o |>: Un cambio a mejor

Cuando se introdujo el operador después, se escribía %>% y puedes encontrar ejemplos de código que lo utilizan. En 2021 se introdujo el operador nativo |>. En la mayor parte de los casos, son reemplazables. En este curso utilizaremos ya el operador nativo porque está disponible desde que empiezas R, sin necesidad de cargar el tidyverse. Te recomendamos que en RStudio vayas al menú Tools>Global options>Code y pongas un tick en la opción Use native pipe operator, |>. De ese modo, cada vez que pulses CTR+MAYUSC+M te saldrá el operador después nativo. Puedes recordarlo como un triángulo orientado, ▷. En las aulas de informática está así configurado. El libro de Wickham ya lo emplea.

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 negaremos que esto es un problema, pero también existen posibles remedios: - Utilizar las chuletas de RStudio - 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).

"2+2 es igual a" |>  paste(2+2)
## [1] "2+2 es igual a 4"

Esto lo podrías leer como A “2+2 es igual a” pégale el resultado de 2+2. Podéis seguir concatenando operaciones. Por ejemplo, para saber la clase del objeto resultante:

"2+2 es igual a" |>  paste(2+2) |>  class()
## [1] "character"

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 class Abreviatura Rstudio
Entero integer int
Real double o numeric num
Lógico logical logi
Alfanumérico character chr
Categóricas factor Factor

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" "array"
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" "r" "s"
## [20] "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. Las data.frame son un tipo de objeto nativo de R. Si queremos usar las tiablas, hay que cargar antes 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
library(tidyverse)
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. Un proyecto está asociado a una carpeta, que puede estar ya creada o la crea RStudio 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.

Desde vuestra cuenta usal 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.

Enlaces útiles

Libros y documentos sobre R

Chuletas de RStudio

Disponibles directamente desde Rsudio

chuletas

Otras referencias en español:

Otras referencias en inglés