Niveles de Fibonacci en Python
Retrocesos de Fibonacci para la acción de Apple calculados con Python
En este artículo vamos a mostrar cómo calcular y trazar niveles de retroceso de Fibonacci de forma sencilla en Python usando varias librerías conocidas como Pandas y matploblib. Como podrá ver el lector el código es relativamente simple y fácil de entender para los que tienen algo de experiencia con este lenguaje.
Introducción
La secuencia de Fibonacci se observa con frecuencia en la naturaleza, las matemáticas y muchas aproximaciones modernas derivadas de la estrecha relación con el ‘número áureo‘. Puede observarse en la disposición natural de las hojas de muchas plantas, en el árbol genealógico de una abeja melífera, y muchos matemáticos creen que también tiene aplicaciones en la acción del precio de un activo, especialmente en la retracción de Fibonacci.
Este modelo de análisis técnico utiliza las 3 proporciones derivadas de la secuencia de Fibonacci para establecer líneas hipotéticas de soporte y resistencia de un activo. Estas proporciones son: 0.618, 0.382 y 0.236, y se calculan mediante la relación entre elementos dentro de la serie, dividiendo un elemento por cada uno de sus 3 elementos precedentes, respectivamente.
En el campo del trading y las finanzas, muchos traders usan la secuencia de Fibonacci en forma de distintas herramientas, como los retrocesos y las extensiones, para predecir posibles puntos de inversión del precio. De hecho, muchas estrategias de trading usan herramientas de Fibonacci para indicar puntos de entrada o de salida óptimos. Aunque muchos traders dudan de la utilidad de los indicadores de Fibonacci, otros consideran que son una herramienta valiosa, aunque a veces sus “buenos resultados” parecen más una profecía autocumplida que otra cosa.
Pueden obtener más información sobre los indicadores de Fibonacci en: Herramientas de Fibonacci en Trading
Código en Python para el trazado de retrocesos de Fibonacci
Vamos a ilustrar este concepto con criptomonedas, ya que son los activos financieros de moda y muchas veces responden bien a los indicadores técnicos, pero el siguiente código funciona para cualquier activo con datos históricos de precios a la mano.
En este punto, suponemos que el lector tiene conocimientos previos de Python y sabe cómo instalar librerías y cosas similares. Así que vamos a comenzar con el código propiamente dicho.
En primer lugar, vamos a importar las librerías que van a hacer las tareas principales del programa.
# Librerías de Python encargadas de importar los datos de precios y hacer el manejo de datos
import requests
import pandas as pd
import numpy as np
from pandas_datareader import data as pdr
from datetime import datetime
import matplotlib.pyplot as plt
plt.style.use('Solarize_Light2')
import yfinance as yf
yf.pdr_override()
Las librerías pandas y numpy sirven para el manejo de grandes cantidades de datos. La librería requests sirve para realizar solicitudes HTTP y obtener información de páginas web. Por su parte, pandas_datareader.data permite obtener datos históricos de precios y matplotlib sirve para crear un gráfico con los datos de precios y trazar los niveles de Fibonacci que se calculan con la siguiente función.
# Librerías de Python encargadas de importar los datos de precios y hacer el manejo de datos
#Función de cálculo de niveles de Fiboncci
def fib_retrace(ticker):
# Obtención de datos de precios
inicio = '2020-01-01'
final = datetime.today()
df = web.DataReader(ticker, data_source='yahoo', start=inicio, end=final)
# Constantes de Fibonacci - Máximo - Mínimo
max_value = df['Close'].max()
min_value = df['Close'].min()
diferencia = max_value - min_value
# Cálculo de niveles de Fibonacci
primer_nivel = max_value - diferencia * 0.236
segundo_nivel = max_value - diferencia * 0.382
tercer_nivel = max_value - diferencia * 0.5
cuarto_nivel = max_value - diferencia * 0.618
# Impresión de niveles de Fibonacci
print('Nivel de porcentaje\t Precio')
print('0.00%\t\t', round(max_value, 3))
print('23.6\t\t', round(primer_nivel, 3))
print('38.2%\t\t', round(segundo_nivel, 3))
print('50%\t\t', round(tercer_nivel, 3))
print('61.8%\t\t', round(cuarto_nivel, 3))
print('100.00%\t\t', round(min_value, 3))
# Trazado del gráfico con retrocesos de Fibonacci
plot_title = 'Retrocesos de Fibonacci para ' + ticker
fig = plt.figure(figsize=(22.5, 12.5))
plt.title(plot_title, fontsize=30)
ax = fig.add_subplot(111)
plt.plot(df.index, df['Close'])
plt.axhline(max_value, linestyle='--', alpha=0.5, color='purple')
ax.fill_between(df.index, max_value, first_level, color='purple', alpha=0.2)
# Colores de las secciones del gráfico
plt.axhline(first_level, linestyle='--', alpha=0.5, color='blue')
ax.fill_between(df.index, first_level, second_level, color='blue', alpha=0.2)
plt.axhline(second_level, linestyle='--', alpha=0.5, color='green')
ax.fill_between(df.index, second_level, third_level, color='green', alpha=0.2)
plt.axhline(third_level, linestyle='--', alpha=0.5, color='red')
ax.fill_between(df.index, third_level, fourth_level, color='red', alpha=0.2)
plt.axhline(fourth_level, linestyle='--', alpha=0.5, color='orange')
ax.fill_between(df.index, fourth_level, min_value, color='orange', alpha=0.2)
plt.axhline(min_value, linestyle='--', alpha=0.5, color='yellow')
plt.xlabel('Fecha', fontsize=20)
plt.ylabel('Precio de cierre (USD)', fontsize=20)
plt.show()
Esta función recibe un símbolo bursátil (en este ejemplo, tomará un ticker de un par de divisas-criptomoneda, pero garantizo que funciona con todos los activos siempre que se agregue el sufijo correspondiente para los intercambios no estadounidenses), extrae datos de Yahoo Finance y los organiza en un marco de datos.
Una vez hecho esto, la función calcula las constantes de Fibonacci, las cuales luego se utilizan para calcular cada nivel de retroceso. Cuando esta función se llama con un símbolo bursátil válido, se obtiene algo similar a lo siguiente.
Retrocesos de Fibonacci para la acción de Apple calculados con Python
¿Cómo se utiliza esta información?
Al igual que con todos los indicadores técnicos, esta información no debe seguirse ciegamente, pero puede ofrecer una visión sobre la “pseudo-aleatoriedad” potencial de la trayectoria de precios, especialmente para activos cíclicos.
Muchos traders utilizarán esto como un indicador de compra, buscando activos que hayan tenido un movimiento de corrección hasta un retroceso de Fibonacci, como una acción que retrocede un 61.8%. En este caso, un trader tomaría una posición larga en la acción porque cree que la acción ha tocado fondo en una línea de soporte y volverá a subir. De manera similar, esta información puede utilizarse como un indicador de venta; si el precio cae por debajo de un soporte, un trader puede considerar que continuará bajando y puede tomar una posición corta.
¿Vale la pena usar Python para calcular indicadores como retrocesos de Fibonacci?
Muchas plataformas de trading como Metatrader 4 permiten calcular retrocesos de Fibonacci y otros indicadores técnicos de forma más simple sin tener que programar nada. Por lo tanto, puede parecer que es una pérdida de tiempo y de trabajo usar Python para hacer esos cálculos.
Sin embargo, Python es un lenguaje muy versátil que permite hacer esto y mucho más. Lo que hicimos con este artículo fue mostrar una pincelada de lo que permite hacer Python y sus múltiples librerías de manejo de datos y análisis técnico.
Por ejemplo, podemos crear un programa que calcule diversos indicadores técnicos como medias móviles y retrocesos de Fibonacci, combine las señales de estos indicadores y genere señales de entrada y salida del mercado. Este sistema de trading puede someterse a pruebas de backtesting (Python también tiene librerías que permiten hacer esto) e incluso mejorarse mediante herramientas de machine learning que también podemos programar.
Las posibilidades son muchas. Por ejemplo, podemos crear screeners personalizados de criptomonedas o acciones que extraigan datos de exchanges, TradingView y otras fuentes similares.
Pueden obtener información sobre las principales librerías de Python para finanzas en: Las mejores librerías para finanzas de Python
