Cómo obtener precios históricos de acciones o ETFs en R

Intro

En este tutorial vamos a cubrir lo siguiente:

• Introducción al paquete quantmod

• Cómo bajar precios históricos usando quantmod

• Manipulación y visualización básica de series de tiempo en R

1 El paquete quantmod

Existen muchos paquetes útiles para finanzas en R. Uno de los más útiles es quantmod. Este paquete lo podemos utilizar para descargar datos históricos, analizar instrumentos financieros y simular estrategias de trading. En este tutorial vamos a cubrir el primer caso y en tutoriales posteriores cubriremos los demás.

Empezamos por instalar el paquete escribiendo lo siguiente en nuestra consola en RStudio:

install.packages(“quantmod”)

Y debemos ver algo como lo siguiente:

Instalando quantmod.

Ahora solo tenemos que cargarlo con el comando que vimos en el tutorial anterior y empezar a descargar los datos que buscamos.

2 Cómo bajar precios históricos usando quantmod

Para bajar precios históricos usaremos la función getSymbols( ) del paquete quantmod. Esta función nos permite conectarnos a diferentes bases de datos (Yahoo Finance por default, pero también puede ser OANDA, la FRED, o nuestras propias fuentes como un CSV o una base de datos SQL). Podemos obtener información sobre esta función cargando quantmod en nuestra sesión y utilizando el shortcut “?” en la consola de RStudio:

library(quantmod)
?getSymbols

Utilizando “?<función>” para leer la documentación de la función de interés.

Hay muchos parámetros que podemos ajustar en esta función. Vemos que el primero de ellos es Symbols. Aquí debemos pasar el ticker o un vector de tickers indicándole a la función que instrumentos queremos descargar a nuestra sesión. Intentemos descargar data del ETF SPY a nuestra sesión:

getSymbols(“SPY”)
head(SPY)

Descargando precios históricos del ETF SPY.

Podemos ver que quantmod creó un objeto xts en nuestro ambiente con precios OHLC (Open: precio de apertura del día, High: precio más alto del día, Low: precio más bajo del día, Close: precio de cierre del día), volumen (títulos intercambiados durante la sesión), y precios de cierre ajustados (por dividendos y splits) del 2007 hasta el último día disponible. En la consola estoy desplegando los datos para los primeros 6 días hábiles del periodo, de 2007-01-03 a 2007-01-10 (pista: utiliza “?head” para ver como más puedes utilizar esta función y experimenta con ella).

Ahora podemos utilizar el siguiente comando para tener una gráfica de velas con los datos del 2021 como las que ves en Yahoo Finance o TradingView:

chartSeries(SPY["2021/"])

Gráfica de velas generada con chartSeries( ).

Utiliza ?getSymbols a ver si puedes modificar lo anterior para que quantmod baje precios mensuales (en vez de diarios como hasta ahora) y grafica los precios mensuales del SPY para lo que va del año usando chartSeries( ).

3 Manipulación y visualización básica de series de tiempo en R

Ahora les voy a compartir un script que pueden utilizar para bajar precios de diferentes ETFs o acciones a la vez y comparen su rendimiento. Les voy a pegar el script completo y explicar cada una de las partes. Para reproducir esto en su computadora, primero creen un archivo de script en RStudio, peguen lo que les comparto a continuación, y guárdenlo con cualquier nombre que prefieran:

1. Crear un archivo de script en RStudio:

   

   Para crear un archivo de script, hagan click en los botones que señalo.

2. Peguen el siguiente texto tal cual en el archivo que se generó:

   # Cargar librerías necesarias
   library(quantmod)
   
   # Ajustar defaults para getSymbols
   today <- as.POSIXlt(Sys.Date())
   today$year <- today$year - 10
   ten_years_ago <- as.Date(today)
   setDefaults(getSymbols.yahoo, from = ten_years_ago)
   
   # Crear ambiente para datos y bajarlos
   etf_data <- new.env()
   etfs <- c("VT", "VTI", "VXUS", "VWO", "VEA")
   getSymbols(etfs, env = etf_data)
   
   # Combinar la columna "Adjusted" de cada ETF en una sola serie de tiempo
   adjusted_list <- lapply(etf_data, Ad)
   adjusted_ts <- do.call(merge, adjusted_list)
   
   # Limpiar la serie de tiempo omitiendo NAs
   adjusted_ts <- na.omit(adjusted_ts)
   
   # Normalizar a 1 para poder compararlos y generar gráfica
   normalize_ts <- function(time_series) {
     for(col in 1:ncol(time_series)) {
       time_series[, col] <- time_series[, col] / drop(coredata(time_series[1, col]))
     }
     return(time_series)
   }
   normalized <- normalize_ts(adjusted_ts)
   names(normalized) <- gsub(".Adjusted", "", names(normalized))
   print(plot(normalized, legend.loc = "topleft", main = "Comparación de ETFs"))

3. Guarden este archivo en el directorio que prefieran con el nombre que prefieran.

Pueden correr este archivo usando el botón Source en la esquina superior derecha de su editor. Al correrlo, deberían ver en su pantalla de RStudio algo similar a esto:

Comparación de 5 ETFs utilizando quantmod.

Analicemos cada parte del script que acabo de compartir con ustedes:

1. Cargar librerías necesarias

   Esta línea es muy simple. Lo único que hago es cargar quantmod puesto que vamos a utilizar sus funciones más adelante en nuestro programa.

2. Ajustar defaults para getSymbols

   Si han estado experimentando con getSymbols, se habrán dado cuenta que siempre baja datos empezando en 2007-01-03 hasta el último día hábil. Este comportamiento puede ajustarse utilizando los parámetros from y to para la función getSymbols.yahoo (esta función es la que se manda a llamar cuando utilizamos la fuente default que es Yahoo Finance, pero nunca debemos llamarla directamente nosotros):

   ?getSymbols.yahoo

   

   Los parámetros from y to para getSymbols.yahoo.

   Yo sólo quiero datos de los últimos 10 años. Por eso creo la variable today en la línea 5 utilizando Sys.Date( ) (esta última función siempre me regresa la fecha local de la máquina que estoy usando). En la línea 6 le resto 10 años a esa fecha. Y por último guardo esta fecha en la variable ten_years_ago en la línea 7. Por último, utilizo la función setDefaults( ) de quantmod en la línea 8 para decirle que siempre que use la función getSymbols.yahoo( ) el parámetro from no va a ser “2007-01-01” como en la imágen anterior sino la fecha de hoy menos 10 años (para mi caso en este momento, 2011-10-11). Si cualquiera de esas líneas te resulta confusa, recuerda que siempre puedes utilizar “?<función>” para revisar la documentación de la función.

3. Crear ambiente para datos y bajarlos

   Aquí lo que estoy haciendo es generar un ambiente nuevo que llamo etf_data para almacenar los datos que quantmod va a descargar. Esto es más conveniente cuando bajas datos para muchos instrumentos por que es mucho más fácil manipularlos después. En la línea 12 genero mi vector de tickers. Pueden buscar en Google estos tickers, todos son ETFs de Vanguard. Por último, en la línea 13 hago mi descarga de datos utilizando getSymbols. Le indico la lista de tickers para los que quiero que descargue datos: etfs, y donde quiero que los guarde: etf_data.

4. Combinar la columna “Adjusted” de cada ETF en una sola serie de tiempo

   En estas dos líneas, lo único que estoy haciendo es agarrar todos los ETFs que descargue en mi ambiente etf_data y aplicándoles la función Ad a cada uno (revisa la documentación de esta función utilizando “?Ad”). Después en la línea 17 combino los resultados de la operación anterior utilizando las funciones do.call( ) y merge( ). Como podrás imaginar por el comentario, lo que estoy haciendo es extraer la columna “<ETF>.Adjusted” para cada ETF y combinándolas en una sola serie de tiempo que contiene sólo precios de cierre ajustados.

5. Limpiar la serie de tiempo omitiendo NAs

   Este es simplemente un paso para evitar problemas más adelante. Si es que no tengo datos para alguna fecha para algún ETF, con la función na.omit( ) me aseguro de eliminar esa línea.

6. Normalizar a 1 para poder compararlos y generar gráfica

   Aquí entramos a lo interesante. Quiero saber cómo se compararía una inversión en los últimos 10 años en cada uno de estos ETFs, así que necesito normalizar los datos para poder comparar manzanas con manzanas. Lo primero que necesito hacer es dividir cada línea por los valores de la primer fecha disponible. Eso me dará el crecimiento de cada dólar invertido en estos ETFs durante los últimos 10 años. Para eso, creo la función normalize_ts( ) en las líneas 23 a 28. Una función en R sigue el siguiente esquema:

   <función> <- function(<parámetros>) {
       <lo que quieras que haga la función>
       return(<lo que quieres que te regrese la función>)
   }

   En este caso, lo que estoy haciendo es irme columna por columna con un ciclo for y dividiendo los valores del ETF para todas las fechas entre el valor de la primera fecha disponible del mismo ETF. Esta serie de tiempo normalizada es la que regreso con la función en la línea 27.

   En la línea 29 utilizo esta función que acabo de definir. La línea 30 es sólo para eliminar el sufijo “.Adjusted” que utiliza quantmod para especificar que esa columna contiene precios ajustados (ya no necesito este sufijo puesto que esta nueva serie de tiempo sólo contiene precios ajustados). Por último, en la línea 31 creo mi gráfica para comparar el rendimiento de los 5 ETFs seleccionados:

   

   Comparación de rendimientos de 5 ETFs de Vanguard para los últimos 10 años.

   Aquí podemos ver que el mejor rendimiento lo ha tenido VTI. Por cada dólar que hubiera invertido hace 10 años, ahorita tendría 4.48 dólares. El peor rendimiento de los últimos 10 años lo tiene VWO, que sólo hubiera multiplicado ese dólar invertido hace 10 años por 1.73:

   

   Utilizando la función tail( ) para observar los útimos valores de nuestra variable normalized.

Espero que este tutorial les haya servido. Este script lo pueden modificar como ustedes prefieran. Intenten comparar los rendimientos de los últimos 3 años para sus acciones favoritas y exploren todos los parámetros de las diferentes funciones que utilizamos en este tutorial. Hasta el próximo tutorial!