análisis de datos financieros

¿Necesita realizar un análisis de datos financieros? Por qué Python es tu mejor herramienta.

Python ofrece una amplia gama de herramientas para acceder, analizar y extraer información de los datos financieros. Aquí le mostramos cómo empezar.

El análisis exploratorio de datos (EDA) es una parte importante del flujo de trabajo de cada científico de datos. EDA permite a los científicos de datos resumir las características más importantes de los datos con los que están trabajando. En el caso del análisis de datos financieros, esto incluye la generación de estadísticas resumidas simples, como la desviación estándar en los rendimientos y los rendimientos promedio, la visualización de las relaciones entre acciones a través de mapas de calor de correlación, la generación de gráficos de series temporales de precios de acciones, diagramas de caja y más.

Consideremos el análisis de tres acciones: Amazon (AMZN), Google (GOOGL) y Apple (AAPL).


Pasos para realizar análisis de datos financieros en Python

  1. Genere estadísticas de resumen y visualizaciones
  2. Analizar el riesgo y el retorno.
  3. Genere indicadores rezagados para comprender las tendencias del precio de las acciones

Esto debería formar una base sólida para el principiante que quiere empezar a aprender a analizar datos financieros en Python. Antes de comenzar, estas son algunas de las herramientas que usaremos.

El pandas-datareader es una biblioteca de Python que permite a los usuarios acceder fácilmente a los datos de precios de acciones y realizar tareas de análisis estadístico, como calcular rendimientos, riesgos, promedios móviles y más. Además, matplotlib y seaborn son bibliotecas en Python que le permiten crear visualizaciones de datos como diagramas de caja y diagramas de series temporales. La combinación de estas bibliotecas permite a los científicos de datos extraer información valiosa de los datos financieros con relativamente pocas líneas de código.

 El análisis de riesgo de las acciones es importante para comprender la incertidumbre en la fluctuación del precio de las acciones. Esto puede ayudar a los inversores a elegir en qué acciones les gustaría invertir según su tolerancia al riesgo. Podemos usar cálculos de promedio móvil para informar mejor las decisiones de inversión mediante la descripción de la tendencia direccional en el movimiento del precio de las acciones. 

Finalmente, los gráficos de la Banda de Bollinger son una forma útil de visualizar la volatilidad de los precios. Los diagramas de bandas de Bollinger y los promedios móviles son lo que llamamos indicadores rezagados. Esto significa que se basan en cambios a largo plazo y nos ayudan a comprender las tendencias a largo plazo. Esto contrasta con los indicadores principales que se utilizan para predecir futuros movimientos de precios. 

Relacionado: Cómo agregar listas en Python

Acceso a datos financieros mediante Pandas-Datareader

Para comenzar, necesitaremos instalar la biblioteca pandas-datareader usando el siguiente comando en la terminal:

pip install pandas-datareader

A continuación, abramos un nuevo script de Python. En la parte superior del script, importemos el objeto web desde el módulo pandas_datareader.data. Importemos también el paquete de fecha y hora incorporado que nos permitirá crear objetos de fecha y hora de Python:

import pandas_datareader.data as web

import datetime

Ahora extraigamos los datos del precio de las acciones de Amazon, almacenémoslos en una variable llamada amzn y mostremos las primeras cinco filas de datos:

amzn = web.DataReader('AMZN','yahoo',start,end)

print(amzn.head())
análisis de datos financieros

Vemos que el marco de datos tiene columnas Alto, Bajo, Abierto, Cerrado, Volumen y Cierre ajustado. Estos valores se basan en los precios de las acciones durante una sesión de negociación que suele ser entre las 9:30 am y las 4:00 pm. Consideremos lo que significa cada una de estas columnas:


Comprender el vocabulario del mercado de valores

  • Precio alto: el precio más alto de una acción durante una sesión de negociación
  • Precio bajo: el precio más bajo de una acción durante una sesión de negociación 
  • Precio de cierre: el precio de una acción al final de una sesión de negociación
  • Precio de apertura: el precio de una acción al comienzo de una sesión de negociación
  • Cierre ajustado: el precio de cierre después de hacer ajustes por división de acciones y dividendos

Lo siguiente que debemos hacer es guardar estos datos en un archivo .csv usando el método pandas to_csv:

amzn.to_csv(f’amzn_{start}_{end}.csv’, index=False)

Ahora que tenemos datos para AMZN, extraigamos datos para GOOGL y AAPL. Comenzaremos con GOOGL y luego pasaremos a AAPL. 

googl = web.DataReader('GOOGL','yahoo',start,end)

print(googl.head())

googl.to_csv(f"googl_{start}_{end}.csv", index=False)
análisis de datos financieros

A continuación, extraigamos AAPL:

aapl = web.DataReader('AAPL','yahoo',start,end)
print(aapl.head())
aapl.to_csv(f"aapl_{start}_{end}.csv", index=False)
análisis de datos financieros

Ahora deberíamos tener tres archivos que contienen dos años de datos de precios de acciones para AMZN, GOOGL y AAPL. Leamos estos archivos en nuevos marcos de datos de pandas:

import pandas as pd 

amzn_df = pd.read_csv(f'amzn_{start}_{end}.csv')

googl_df = pd.read_csv(f'googl_{start}_{end}.csv')   

aapl_df = pd.read_csv(f'aapl_{start}_{end}.csv')   

 

Exploración y visualización de datos financieros 

A continuación podemos generar algunas estadísticas simples. Una métrica importante para comprender los movimientos del precio de las acciones es el rendimiento. El retorno se define como el precio de apertura menos el precio de cierre dividido por el precio de apertura (R = [abrir-cerrar]/abrir). Calculemos los rendimientos de cada ticker. Empecemos por calcular los rendimientos diarios de AMZN:

amzn_df['Returns'] = (amzn_df['Open'] - amzn_df['Close'])/amzn_df['Open']
análisis de datos financieros

Una visualización simple que podemos crear es un histograma para los rendimientos diarios en el precio de las acciones de AMZN. Podemos usar seaborn para diseñar y matplotlib para generar un histograma:

import matplotlib.pyplot as plt

import seaborn as sns 

amzn_df['Returns'] = (amzn_df['Open'] - amzn_df['Close'])/amzn_df['Open']

amzn_df['Returns'].hist()

plt.title('AMZN Stock Price Returns Distribution')

plt.show()
análisis de datos financieros

Y podemos repetir esto para GOOGL:

googl_df['Returns'] = (googl_df['Open'] - googl_df['Close'])/googl_df['Open']

googl_df['Returns'].hist()

plt.title('GOOGL Stock Price Returns Distribution')

plt.show()
análisis de datos financieros

y AAPL:

aapl_df['Returns'] = (aapl_df['Open'] - aapl_df['Close'])/aapl_df['Open']

aapl_df['Returns'].hist()

plt.title('AAPL Stock Price Returns Distribution')

plt.show()
análisis de datos financieros

También podemos calcular los rendimientos medios y la desviación estándar de los rendimientos de cada acción y mostrarlos en el título del histograma. Estas estadísticas son muy importantes para los inversores. Los rendimientos medios nos dan una idea de la rentabilidad de una inversión en acciones. La desviación estándar es una medida de cuánto fluctúan los rendimientos. A esto lo llamamos riesgo en el mundo financiero. Por lo general, los riesgos más altos se asocian con rendimientos más altos. Mostremos un ejemplo para AMZN. Primero almacenamos la media y la desviación estándar en variables y usamos f-strings para formatear el título:

mean_amnz_returns = np.round(amzn_df['Returns'].mean(), 5)

std_amnz_returns = np.round(amzn_df['Returns'].std(), 2)

plt.title(f'AMZN Stock Price Returns Distribution; Mean {mean_amnz_returns}, STD: {std_amnz_returns}')

plt.show()
análisis de datos financieros

Otra visualización de datos útil son los diagramas de caja. Similar a los histogramas, esta es otra forma de visualizar la media, la dispersión y la asimetría de los datos. En el contexto de nuestros datos financieros, puede ayudarnos a comparar los rendimientos medios, la dispersión de los rendimientos y la asimetría de los rendimientos de cada acción, lo que puede ayudar a informar las decisiones de inversión. Primero, combinemos los rendimientos de cada acción en un solo marco de datos:

amzn_df['Ticker'] =  'AMZN'

googl_df['Ticker'] =  'GOOGL'

aapl_df['Ticker'] =  'AAPL'

df = pd.concat([amzn_df, googl_df, aapl_df])

df = df[['Ticker', 'Returns']]

print(df.head())
análisis de datos financieros

Para generar boxplots usamos el siguiente código:

sns.boxplot(x= df['Ticker'], y = df['Returns'])
plt.title('Box Plot for AMZN, GOOGL and AAPL Returns')
plt.show()
análisis de datos financieros

La visualización final que analizaremos es el mapa de calor de correlación para las devoluciones. Esta visualización nos ayuda a comprender si existen relaciones lineales entre los rendimientos del precio de las acciones. Esto es importante porque puede proporcionar información sobre la relación entre las acciones en la cartera de un inversor y, como resultado, también puede ayudar a informar cómo un inversor construye su cartera. Para crear nuestro mapa de calor, primero creemos un nuevo marco de datos que contenga una columna para cada ticker:

df_corr = pd.DataFrame({'AMZN':amzn_df['Returns'], 'GOOGL':googl_df['Returns'], 'AAPL':aapl_df['Returns']})
análisis de datos financieros

A continuación, calculemos la correlación entre los rendimientos de cada acción:

análisis de datos financieros

Este mapa de calor muestra que cada una de estas acciones tiene una relación lineal positiva. Esto significa que cuando aumentan los rendimientos diarios de AMZN, es probable que también aumenten AAPL y GOOGL. Lo contrario también es cierto. Si los rendimientos de AMZN disminuyen, es probable que los demás también disminuyan. Una buena cartera de inversiones contiene activos diversificados. En este contexto, esto significa que debemos seleccionar acciones que no estén fuertemente correlacionadas entre sí, como AAPL, AMZN y GOOGL. Esto se debe a que si los rendimientos de una acción caen, los rendimientos de toda su cartera también disminuirán. En una cartera diversificada con acciones que no están correlacionadas, el precio de una acción no necesariamente disminuirá o aumentará junto con otras. 

Relacionado: Una guía completa para la visualización de datos con Matplotlib y Seaborn

Indicadores de retraso 

Los siguientes cálculos por los que pasaremos son dos tipos diferentes de indicadores rezagados, la media móvil y las gráficas de bandas de Bollinger. El promedio móvil es una técnica común que utilizan los analistas para suavizar las fluctuaciones a corto plazo en los precios de las acciones para comprender las tendencias en la dirección del precio. Aquí trazaremos el promedio móvil de AMZN, GOOGL y AAPL. Comencemos con AMZN. Trazaremos el promedio móvil de 10 días para el precio de cierre ajustado de AMZN y consideraremos los precios de las acciones después del 23 de enero de 2021:

cutoff = datetime.datetime(2021,1,23)

amzn_df['Date'] = pd.to_datetime(amzn_df['Date'], format='%Y/%m/%d')

amzn_df = amzn_df[amzn_df['Date'] > cutoff]

amzn_df['SMA_10'] = amzn_df['Close'].rolling(window=10).mean()

print(amzn_df.head())

plt.plot(amzn_df['Date'], amzn_df['SMA_10'])

plt.plot(amzn_df['Date'], amzn_df['Adj Close'])

plt.title("Moving average and Adj Close price for AMZN")

plt.ylabel('Adj Close Price')

plt.xlabel('Date')

plt.show()
análisis de datos financieros

En el gráfico anterior, la línea azul es la media móvil y la naranja es el precio de cierre ajustado. Podemos hacer lo mismo para GOOGL:

googl_df['Date'] = pd.to_datetime(googl_df['Date'], format='%Y/%m/%d')

googl_df = googl_df[googl_df['Date'] > cutoff]

googl_df['SMA_10'] = googl_df['Close'].rolling(window=10).mean()

print(googl_df.head())

plt.plot(googl_df['Date'], googl_df['SMA_10'])

plt.plot(googl_df['Date'], googl_df['Adj Close'])

plt.title("Moving average and Adj Close price for GOOGL")

plt.ylabel('Adj Close Price')

plt.xlabel('Date')

plt.show()
análisis de datos financieros

Y finalmente AAPL:

aapl_df['Date'] = pd.to_datetime(aapl_df['Date'], format='%Y/%m/%d')

aapl_df = aapl_df[aapl_df['Date'] > cutoff]

aapl_df['SMA_10'] = aapl_df['Close'].rolling(window=10).mean()

print(googl_df.head())

plt.plot(aapl_df['Date'], aapl_df['SMA_10'])

plt.plot(aapl_df['Date'], aapl_df['Adj Close'])

plt.title("Moving average and Adj Close price for AAPL")

plt.ylabel('Adj Close Price')

plt.xlabel('Date')

plt.show()
análisis de datos financieros

El último tipo de gráfico del que hablaré es el gráfico de la Banda de Bollinger, que es una forma de visualizar la dispersión en la media móvil. Las bandas están definidas por límites superior e inferior que están a dos desviaciones estándar del promedio móvil simple. Esto es útil para los comerciantes porque les permite aprovechar las fluctuaciones en las volatilidades de los precios. Generemos un gráfico de Bandas de Bollinger para AMZN:

amzn_df['SMA_10_STD'] = amzn_df['Adj Close'].rolling(window=20).std() 

amzn_df['Upper Band'] = amzn_df['SMA_10'] + (amzn_df['SMA_10_STD'] * 2)

amzn_df['Lower Band'] = amzn_df['SMA_10'] - (amzn_df['SMA_10_STD'] * 2)

amzn_df.index = amzn_df['Date']

amzn_df[['Adj Close', 'SMA_10', 'Upper Band', 'Lower Band']].plot(figsize=(12,6))

plt.title('10 Day Bollinger Band for Amazon')

plt.ylabel('Adjusted Close Price')

plt.show()
análisis de datos financieros

Y para GOOGL:

googl_df['SMA_10_STD'] = googl_df['Adj Close'].rolling(window=10).std() 

googl_df['Upper Band'] = googl_df['SMA_10'] + (googl_df['SMA_10_STD'] * 2)

googl_df['Lower Band'] = googl_df['SMA_10'] - (googl_df['SMA_10_STD'] * 2)

googl_df.index = googl_df['Date']

googl_df[['Adj Close', 'SMA_10', 'Upper Band', 'Lower Band']].plot(figsize=(12,6))

plt.title('10 Day Bollinger Band for Google')

plt.ylabel('Adjusted Close Price')

plt.show()
análisis de datos financieros

Y finalmente para AAPL:

aapl_df['SMA_10_STD'] = aapl_df['Adj Close'].rolling(window=10).std() 
aapl_df['Upper Band'] = aapl_df['SMA_10'] + (aapl_df['SMA_10_STD'] * 2)
aapl_df['Lower Band'] = aapl_df['SMA_10'] - (aapl_df['SMA_10_STD'] * 2)
aapl_df.index = aapl_df['Date']
aapl_df[['Adj Close', 'SMA_10', 'Upper Band', 'Lower Band']].plot(figsize=(12,6))
plt.title('10 Day Bollinger Band for Apple')
plt.ylabel('Adjusted Close Price')
plt.show()
análisis de datos financieros

Si está interesado en acceder al código utilizado anteriormente, está disponible en GitHub.

Existe una amplia variedad de herramientas útiles para extraer, analizar y generar información a partir de datos financieros. La combinación de estas herramientas facilita que los principiantes comiencen a trabajar con datos financieros en Python. Juntas, estas habilidades se pueden usar para inversiones personales, operaciones algorítmicas, creación de carteras y más. Ser capaz de generar rápidamente información estadística, visualizar relaciones e identificar tendencias en datos financieros es invaluable para cualquier analista o científico de datos interesado en finanzas.