¿Estás interesado en el trading algorítmico pero no sabes por dónde empezar? No busques más. En este post te guiaremos a través del proceso de desarrollo de tu propio bot de trading utilizando Python. Cubriremos los pasos esenciales de preparación de datos, creación de señales de trading, cálculo de pérdidas y ganancias, y automatización del proceso de trading. Nuestra estrategia elegida es la de medias móviles, y utilizaremos las librerías yfinance y pandas para la carga y manipulación de datos.

Incluso si eres nuevo en el mundo de Python y los bots de trading, ¡no te preocupes! Hemos diseñado este artículo para que sea fácil de entender. Al final tendrás el conocimiento y la confianza para desarrollar tu propio bot de trading y hacer operaciones rentables. Así que, ¡empecemos tu viaje para convertirte en un experto en trading algorítmico!

Preparación de los datos

La preparación de datos es un paso esencial en cualquier tarea de análisis de datos. Y el desarrollo de robots de negociación no es una excepción. En este paso, estandarizamos el formato de los datos para asegurarnos de que podemos manipularlos y analizarlos eficientemente. En este post, vamos a utilizar la librería yfinance para cargar los datos financieros y pandas para procesar y analizar esos datos.

El objetivo es poder volver a utilizar el código en un futuro con otros datos, por eso preprocesamos los datos al principio.

Para empezar, importaremos las librerías necesarias y definiremos una función para recuperar y preprocesar los datos usando yfinance. La función descargará los datos, renombrará las columnas y eliminará los valores que falten. También eliminaremos la columna "adj close", ya que no es necesaria para nuestro análisis.

import numpy as np
import pandas as pd
import yfinance as yf
import warnings
warnings.filterwarnings("ignore")

def preprocessing_yf(symbol):

  # Importar los datos
  df = yf.download(symbol).dropna()

  # Renombrar las columnas
  df.columns = ["open", "high", "low", "close", "adj close", "volume"]
  df.index.name = "time"

  # Eliminar la columna adj close
  del df["adj close"]

  return df

df = preprocessing_yf("EURUSD=X")
df

A continuación, llamaremos a esta función para nuestro activo deseado, en este caso, el par de divisas EUR/USD. Almacenaremos el data frame resultante en una variable llamada df.

Al final del paso de preparación de datos, tendremos un data frame estandarizado listo para nuestro análisis.

Creación de señales de bots de trading

Una vez que hemos estandarizado los datos, el siguiente paso es crear las señales del bot de trading. Estas señales nos indican cuándo comprar o vender un activo en función de unas condiciones específicas. En este post, utilizaremos una estrategia de medias móviles para generar señales de trading.

Para definir nuestras posiciones de compra y venta, utilizaremos dos medias móviles simples (SMA) de diferentes periodos de tiempo. Utilizaremos una SMA de período más corto y una SMA de período más largo, y definiremos una posición de compra cuando la SMA más corta cruce por encima de la SMA más larga, y una posición de venta cuando la SMA más corta cruce por debajo de la SMA más larga. Para nuestro análisis, tomaremos 30 y 60 periodos, pero más adelante te mostraremos cómo cambiar estos valores.

Para implementar la estrategia, primero calcularemos las dos SMA utilizando la función rolling() de pandas. A continuación crearemos una columna vacía llamada señal para almacenar nuestras señales de compra y venta. Definiremos nuestra condición de señal de compra como el cruce de la SMA más corta por encima de la SMA más larga, y nuestra condición de señal de venta como el cruce de la SMA más corta por debajo de la SMA más larga. Utilizaremos la función loc[] para establecer los valores de la columna de señales en 1 para las señales de compra y -1 para las señales de venta.

# Crear media móvil simple con periodo de 30 días
df["SMA fast"] = df["close"].rolling(30).mean()

# Crear media móvil simple con periodo de 60 días
df["SMA slow"] = df["close"].rolling(60).mean()

# Crear la condición
condition_buy = (df["SMA fast"] > df["SMA slow"]) & 
                (df["SMA fast"].shift(1) < df["SMA slow"].shift(1))
condition_sell = (df["SMA fast"] < df["SMA slow"]) & 
                 (df["SMA fast"].shift(1) > df["SMA slow"].shift(1))

df.loc[condition_buy, "signal"] = 1
df.loc[condition_sell, "signal"] = -1

Para visualizar las señales, utilizaremos matplotlib para crear un gráfico de líneas del precio de cierre del activo con las señales de compra y venta trazadas como triángulos verdes y triángulos rojos apuntando hacia abajo, respectivamente. También vamos a trazar las dos SMA y el precio de cierre del activo para el contexto adicional.

year = "2019"

# Seleccionar toda la señal en una lista de índices para trazar sólo estos puntos
idx_open = df.loc[df["signal"] == 1].loc[year].index
idx_close = df.loc[df["signal"] == -1].loc[year].index

# Adaptar el tamaño de la figura
plt.figure(figsize=(15,6))

# Trazar los puntos de la señal larga abierta en verde y de venta en rojo
plt.scatter(idx_open, df.loc[idx_open]["close"].loc[year], 
            color= "#57CE95", marker="^")
plt.scatter(idx_close, df.loc[idx_close]["close"].loc[year],  
            color= "red", marker="v")

# Trazar la resistencia para asegurarte de que se cumplen las condiciones
plt.plot(df["close"].loc[year].index, df["close"].loc[year], alpha=0.35)
plt.plot(df["close"].loc[year].index, df["SMA fast"].loc[year], alpha=0.35)
plt.plot(df["close"].loc[year].index, df["SMA slow"].loc[year], alpha=0.35)

# Mostrar el gráfico
plt.show()

Figura 1: Verificación de las señales de trading

Cálculo de pérdidas y ganancias de un bot de trading en Python

Una vez que tenemos nuestras señales de trading, podemos empezar a evaluar su rentabilidad calculando el rendimiento de la estrategia. En esta sección, calcularemos la rentabilidad de nuestra estrategia de trading con medias móviles, incorporaremos los costes de transacción y trazaremos la rentabilidad acumulada de la estrategia.

Para calcular la rentabilidad de nuestra estrategia de trading, primero determinaremos nuestra posición de trading rellenando los valores NaN de la columna de señal con el valor anterior no nulo utilizando la función fillna(). A continuación, calcularemos el cambio porcentual en el precio del activo utilizando la función pct_change(). Por último, calcularemos la rentabilidad de la estrategia multiplicando el cambio porcentual por la posición de trading del periodo anterior.

Decimos señal cuando abrimos o cerramos una operación y posición para hablar de todo el tiempo que estamos en una operación. Te ponemos un ejemplo, señal = (1, Nan, Nan, Nan, -1, Nan, Nan) -> Posición=(1, 1, 1, 1, -1, -1, -1).

# Crear la posición
df["position"] = df["signal"].fillna(method="ffill")

# Calcular el porcentaje de variación del activo
df["pct"] = df["close"].pct_change(1)

# Calcular la rentabilidad de la estrategia
df["return"] = (df["pct"] * df["position"].shift(1))

En el trading real, incurrimos en costes de transacción cada vez que compramos o vendemos un activo. Para incorporar los costes de transacción a la rentabilidad de nuestra estrategia, crearemos una nueva columna llamada coste para almacenar el coste de cada transacción, que será una cantidad fija por transacción. A continuación, restaremos el coste de la rentabilidad de cada periodo. Aquí coste = 0.0001, que significa 0.01%. Ojo, dependiendo del activo, hay que adaptar el coste. Por ejemplo, en las criptomonedas, el coste puede ser 5 veces o 10 veces mayor, ¡incluso más, porque la volatilidad es mucho mayor que en el mercado Forex!

Figura 2: Verificación de las señales de trading

Automatización del proceso

Ahora que hemos desarrollado una estrategia de trading, podemos automatizar el proceso mediante la creación de una función para aplicar la estrategia a diferentes activos. En esta sección, vamos a crear una función que toma un símbolo de activo como entrada y devuelve el rendimiento acumulado de la estrategia de trading de medias móviles en ese activo. Luego probaremos la función en un activo diferente.

Crearemos una nueva función llamada SMA_strategy que toma un símbolo de activo, tamaños de ventana de media móvil rápida y lenta, y coste de transacción como entradas. La función preprocesará los datos, creará las señales de trading, calculará la rentabilidad de la estrategia con los costes de transacción y devolverá la rentabilidad acumulada de la estrategia.

def SMA_strategy(input, fast_sma = 30, slow_sma = 60, cost_ind = 0.0001):

df = preprocessing_yf(input)

# Crear medias móviles rápidas y lentas
df["SMA fast"] = df["close"].rolling(fast_sma).mean()
df["SMA slow"] = df["close"].rolling(slow_sma).mean()

# Crear señales de trading
df["signal"] = np.nan
condition_buy = (df["SMA fast"] > df["SMA slow"]) & 
                (df["SMA fast"].shift(1) < df["SMA slow"].shift(1))
condition_sell = (df["SMA fast"] < df["SMA slow"]) & 
                 (df["SMA fast"].shift(1) > df["SMA slow"].shift(1))
df.loc[condition_buy, "signal"] = 1
df.loc[condition_sell, "signal"] = -1

# Calcular la rentabilidad de la estrategia con costes de transacción
df["position"] = df["signal"].fillna(method="ffill")
df["cost"] = (np.abs(df["signal"]) * cost_ind).fillna(value=0)
df["pct"] = df["close"].pct_change(1)
df["return"] = (df["pct"] * df["position"].shift(1) - df["cost"])*100

# Devuelve la rentabilidad acumulada de la estrategia
return df["return"].cumsum()

Para probar la función en un activo diferente, podemos simplemente pasar un nuevo símbolo de activo a la función. En este caso, probaremos la función con el índice S&P 500 utilizando el símbolo SPY.

SMA_strategy("BTC-USD", 30,60, 0.0001).cumsum().plot(figsize=(15,6), 
             title="Return for the Trend trading stratgey", ylabel="P&L in %")
plt.show()

Figura 3: Beneficio global (comisiones incluidas) de una estrategia de negociación tendencial en Bitcoin

En este post hemos mostrado cómo construir un bot de trading básico usando Python. Desarrollamos una estrategia de trading de medias móviles y mostramos cómo calcular la rentabilidad de la estrategia con los costes de transacción. También automatizamos el proceso creando una función que aplica la estrategia a diferentes activos.

Python es un potente lenguaje para la negociación algorítmica debido a su sencillez, flexibilidad y velocidad. Con Python, los traders pueden realizar fácilmente pruebas retrospectivas y optimizar las estrategias de trading, así como automatizar el proceso de trading con un bot de trading.

Sin embargo, es importante tener en cuenta que la creación de un bot de trading rentable requiere un profundo conocimiento de las finanzas, los mercados y la programación. También es importante realizar pruebas exhaustivas y gestionar el riesgo para garantizar que la estrategia es sólida y puede hacer frente a diferentes condiciones de mercado.

Con el conocimiento y las herramientas proporcionadas en este artículo, puedes empezar a explorar el mundo del trading algorítmico y desarrollar tus propias estrategias de trading rentables.

¿Quieres saber más sobre trading algorítmico?

En Frogames te ofrecemos una ruta completa de trading algorítmico que te permitirá aprender desde cero y adentrarte con seguridad en el emocionante mundo del trading algorítmico. Nuestros cursos te brindarán los conocimientos necesarios sobre análisis técnico, programación en Python y estrategias de trading automatizadas. ¡Descubre cómo convertirte en un trader exitoso con Frogames!