Instalación y configuración de R y Python

En este tutorial se dan las indicaciones para la instalación del software necesario para ejecutar las aplicaciones econométricas de cada tema del curso.

Nota introductoria

En las distintas aplicaciones del libro se usan los lenguajes de programación R (https://www.r-project.org/) y Python (https://www.python.org), utilizando RStudio (https://www.rstudio.com/) como entorno de ejecución (IDE) de dichos lenguajes. También se utilizará la nueva IDE Positron (https://github.com/posit-dev/positron), “una herramienta extensible y políglota que permite escribir código y explorar datos” de forma sencilla.

Igualmente pueden emplearse otras IDEs alternativas, como JupyterLab (https://jupyter.org/), Visual Studio Code (https://code.visualstudio.com/), Google Colab (https://colab.google/), Amazon SageMaker Studio Lab (https://studiolab.sagemaker.aws/), DataCamp Workspace (https://www.datacamp.com/workspace) o Deepnote Worspace (https://deepnote.com/workspace).

Instalación y configuración de R en RStudio

  1. Descargar e instalar R y RStudio: https://posit.co/download/rstudio-desktop/

  2. Instalar el software Rtools (sólo en Windows): https://cran.r-project.org/bin/windows/Rtools/

  3. Desde R, instalar la librería Rcpp:

Code 
install.packages("Rcpp")
  1. Abrir RStudio e instalar la colección de librerías tidyverse (https://www.tidyverse.org/), y opcionalmente las librerías shiny y tidymodels:
Code 
# Librerías básicas para analizar y explorar
install.packages("tidyverse")
# Librerías complementarias (opcionales)
# Para comunicar e interactuar
install.packages("shiny")
# Para modelizar y predecir
install.packages("tidymodels")
  1. Una vez instalados R y RStudio, y sus librerías generales básicas, el siguiente paso consiste en instalar las librerías específicas para realizar análisis de tipo estadístico y/o econométrico. Hay una gama muy amplia de paquetes disponibles en R, aunque afortunadamente la mayoría de las librerías más populares, o muy especializadas, están agrupadas en diferentes categorías en CRAN TASK Views (https://cran.r-project.org/web/views/). Para descargarse estos paquetes de macro-librerías, primero debe instalarse la librería ctv, y posteriormente se instalarán los grupos de librerías homogéneos:
Code 
install.packages("ctv")
Code 
# Librerías básicas de econometría
ctv::install.views("Econometrics")
# Librerías complementarias (opcionales)
ctv::install.views("TimeSeries")
ctv::install.views("MissingData")
ctv::install.views("Robust")
ctv::install.views("Finance")
ctv::install.views("Spatial")
ctv::install.views("SpatioTemporal")

Es recomendable instalar sólo los paquetes necesarios para el análisis econométrico “básico”, https://cran.r-project.org/web/views/Econometrics.html. Siempre se pueden instalar paquetes adicionales más adelante; así, la IDE RStudio instalada nos avisará cuándo un script contenga alguna librería no instalada y nos dará la opción de descargarla antes de ejecutar el código.

No obstante el comentario anterior, tras la instalación de la macro-librería Econometrics, para la ejecución de todos los scripts de R correspondientes a la aplicaciones econométricas seleccionadas en el libro se necesitan algunas librerías específicas que se detallan a continuación, las cuales pueden instalarse desde el principio, o instalarlas cuando RStudio lo pida a la vista de la líneas de cógigo de R que se intenten ejecutar:

Code 
install.packages("DataEditR")
install.packages("skimr")
install.packages("modelsummary")
install.packages("easystats")
install.packages("effects")
install.packages("marginaleffects")
install.packages("jtools")
install.packages("esquisse")
install.packages("plotly")
install.packages("gganimate")
install.packages("ggstatsplot")
install.packages("viridis")
install.packages("RColorBrewer")
install.packages("stargazer")
install.packages("huxtable")
install.packages("fpp3")
install.packages("timetk")
install.packages("TSstudio")
install.packages("gvlma")
install.packages("alr4")
install.packages("skedastic")
install.packages("nlWaldTest")
install.packages("orcutt")
install.packages("faraway")
install.packages("mi")
install.packages("Amelia")
install.packages("mice")
install.packages("mctest")
install.packages("rugarch")
install.packages("rmgarch")
install.packages("ivreg")
install.packages("sampleSelection")
install.packages("geojsonsf")
install.packages("leaflet")
install.packages("sf")
install.packages("mapsf")
install.packages("mapview")
install.packages("tmap")
install.packages("spdep")
install.packages("spatialreg")
install.packages("tidyquant")
install.packages("scales")
install.packages("palmerpenguins")
install.packages("nycflights13")

Instalación y configuración de Python en RStudio

Hay varias formas de configurar Python en el ordenador. Los tres métodos más frecuentes son los siguientes:

  1. Distribución estándar: https://www.python.org/
  2. Distribución Anaconda: https://www.anaconda.com/
  3. Distribución Miniconda: https://docs.conda.io/en/latest/miniconda.html

Tanto la distribución Anaconda como la Miniconda utilizan la librería conda en sus instalaciones de Python, la cual permite descargar e instalar paquetes adicionales de Python. La instalación estándar de Python utiliza pip para descargar e instalar librerías adicionales de Python.

Para las necesidades de este libro, donde se ejecutarán simultáneamente líneas de código (chunks) en R y Python, hay que disponer en el ordenador de una las distribuciones, Python estándar o Miniconda. Veamos a continuación cómo hacerlo; los detalles pueden encontrarse aquí.

Si se usa la primera distribución, Python estándar, lo primero que hay que hacer es ir a la página de descargas de la web oficial de Python, https://www.python.org/downloads/, y luego buscar e instalar la versión correspondiente al sistema operativo utilizado.

A continuación, una vez realizada la instalación, para configurar el entorno de Python en RStudio hay que instalar y ejecutar la librería de R reticulate:

Code 
install.packages("reticulate")
library(reticulate)

y luego hay que realizar las acciones siguientes desde RStudio: ir al menú de herramientas (Tools), luego a opciones globales (Global Options), y en el listado de la izquierda (Options) hay que ir a Python y asignar en la casilla del intérprete el directorio donde está instalado el software.

Por ejemplo, si se tiene instalado Python 3.XX en un ordenador con el sistema operativo Windows o macOS, y se quiere utilizar esa versión, debe utilizarse la siguiente línea de comandos indicando la localización correspondiente a la instalación de Python:

Code 
library(reticulate)
use_python("C:/.../python3.XX") # En Windows
use_python("/usr/local/bin/python3.XX") # En macOS

Si se elige la segunda distribución, Miniconda, lo único que hay que hacer es configurar el entorno de Python en RStudio con la librería de R reticulate. Así, una vez instalada esta última, cuando se ejecuta por primera vez dicho paquete se crea una instalación miniconda adaptada a R llamada R-Miniconda; también se puede instalar miniconda manualmente utilizando el comando install_miniconda().

Code 
install.packages("reticulate")
library(reticulate)
install_miniconda()

Sea cual sea la opción elegida, Python estándar o Miniconda, para comprobar que existe alguna instalación de Python disponible se pueden usar los siguientes comandos en R:

Code 
conda_list()
conda_version()
py_config()

Si no aparece ninguna instalación de Python hay que volver a intentar la instalación de Python estándar o la versión Miniconda.

Para comprobar que el entorno Python se ha creado adecuadamente se puede entrar en la consola de Python y hacer algún cálculo sencillo para ver si la instalación es correcta.

Así, desde R, tras cargar la librería reticulate, se debe usar el comando repl_python() y luego, ya en la consola de Python, se pueden teclear por ejemplo los siguientes comandos:

  • import numpy as np
  • a = np.sqrt(2)
  • print(a)
  • x = 42*2
  • print(x)
  • exit

También se pueden ejecutar algunos comandos Python desde R importando la librería correspondiente:

Code 
library(reticulate)
np <- import("numpy")
np$sqrt(2)

O se puede ejecutar un script de Python y mostrar los resultados en RStudio:

Code 
from matplotlib import pyplot as plt
import numpy as np
x = list(range(1, 11))
y = np.random.randn(10)
plt.figure(0)
plt.plot(x, y,  linestyle = "--", color = "blue", marker = "s", label = "Línea 1")
plt.title("Ejemplo de gráfico de líneas")
plt.legend(loc = "upper left")
plt.show()

Instalación de librerías Python

El último paso consiste en instalar las librerías necesrias en el entorno de Python recién creado.

Si se usa la versión estándar de Python, se instalarán las librerías a través del comando pip en el terminal de Windows o macOS:

  • pip install --upgrade nombre-librería (en Windows)

  • pip3 install --upgrade nombre-librería (en macOS)

Si se utiliza R-Miniconda a través de reticulate, se pueden instalar las librerías desde RStudio utilizando el comando py_install. Debajo se muestran los comandos necesarios para la instalación de todas las librerías Python necesarias en este libro; si se utilizase la opcíon Python estándar habría que usar el comando pip mostrado anteriormente, instalando una a una todas las librerías sugeridas.

Code 
library(reticulate)
py_install("numpy", pip = TRUE)
py_install("pandas", pip = TRUE)
py_install("statsmodels", pip = TRUE)
py_install("matplotlib", pip = TRUE)
py_install("matplotlib_scalebar", pip = TRUE)
py_install("seaborn", pip = TRUE)
py_install("plotly", pip = TRUE)
py_install("plotnine", pip = TRUE)
py_install("pandas-bokeh", pip = TRUE)
py_install("scipy", pip = TRUE)
py_install("scikit-learn", pip = TRUE)
py_install("scikit-misc", pip = TRUE)
py_install("linearmodels", pip = TRUE)
py_install("arch", pip=TRUE)
py_install("datetime", pip =  TRUE)
py_install("stargazer", pip = TRUE)
py_install("xlrd", pip = TRUE)
py_install("openpyxl", pip = TRUE)
py_install("category_encoders", pip = TRUE)
py_install("skimpy", pip = TRUE)
py_install("yfinance", pip = TRUE)
py_install("geopandas", pip = TRUE)
py_install("folium", pip = TRUE)
py_install("leafmap", pip = TRUE)
py_install("chart_studio", pip = TRUE)
py_install("pysal", pip = TRUE)
py_install("palmerpenguins", pip = TRUE)