Trading Algorítmico: cómo escribir tus propias estrategias con Python

El trading algorítmico ha dejado de ser un privilegio exclusivo de los fondos de cobertura y los grandes jugadores del mercado. Gracias a Python y a las bibliotecas abiertas, cualquiera puede escribir sus propias estrategias de trading, automatizar el proceso e incluso crear un sistema rentable. En este artículo, exploraremos cómo escribir algoritmos de trading, qué herramientas usar y cómo probar tus estrategias antes de lanzarlas.

1. ¿Por qué Python?

Python es el lenguaje principal para el trading algorítmico por varias razones:

• Simplicidad en la sintaxis — Permite escribir y probar el código rápidamente.
• Rica ecosistema — Bibliotecas para trabajar con datos, análisis, machine learning y APIs de exchanges.
• Flexibilidad — Capacidad de integrarse con brokers, exchanges de criptomonedas, servidores y soluciones en la nube.

Bibliotecas populares para trading con Python:

• pandas — Análisis y procesamiento de datos.
• numpy — Cálculos matemáticos rápidos.
• ccxt — Conexión con exchanges de criptomonedas a través de APIs.
• backtrader o zipline — Prueba de estrategias.
• ta — Indicadores de análisis técnico.

2. Arquitectura de un bot de trading

Un trader algorítmico típico se compone de los siguientes módulos:

1. Obtención de datos
   • Solicitar precios del exchange a través de API.
   • Almacenar los datos en caché o en una base de datos.
2. Análisis de datos
   • Calcular indicadores (SMA, RSI, MACD, etc.).
   • Detectar patrones y tendencias.
3. Toma de decisiones
   • Desarrollar el algoritmo que determina los puntos de entrada y salida.
   • Gestión de riesgos (stop-loss, take-profit).
4. Ejecución de órdenes
   • Enviar órdenes a través de la API del exchange.
   • Monitorear la ejecución de las órdenes.
5. Registro y monitoreo
   • Registrar los datos de las transacciones.
   • Monitorear errores y ajustar la estrategia.

3. Conectarse a un exchange y obtener datos

Conectémonos al exchange de criptomonedas Binance con ccxt y descarguemos datos históricos:

import ccxt
import pandas as pd

# Conectar a Binance
exchange = ccxt.binance()

# Obtener datos históricos de BTC/USDT
bars = exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100)

# Convertir a DataFrame
df = pd.DataFrame(bars, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

print(df.tail())

Ahora tenemos los datos con los que podemos trabajar.

4. Desarrollo de una estrategia simple (Cruce de SMA)

Una de las estrategias más simples es el cruce de dos medias móviles (SMA). Si la SMA corta cruza la SMA larga hacia arriba — compramos, si es hacia abajo — vendemos.

Implementémosla:

import numpy as np

# Calcular medias móviles
df['SMA_50'] = df['close'].rolling(window=50).mean()
df['SMA_200'] = df['close'].rolling(window=200).mean()

# Generar señales
df['signal'] = np.where(df['SMA_50'] > df['SMA_200'], 1, -1)

print(df.tail())

Este código añade una columna signal, donde 1 indica comprar y -1 vender.

5. Backtesting de la estrategia

Antes de ejecutar la estrategia en vivo, es crucial probarla con datos históricos. Usamos backtrader:

import backtrader as bt

class SmaCross(bt.Strategy):
    params = dict(short_period=50, long_period=200)

    def __init__(self):
        self.sma_short = bt.indicators.SimpleMovingAverage(period=self.params.short_period)
        self.sma_long = bt.indicators.SimpleMovingAverage(period=self.params.long_period)

    def next(self):
        if self.sma_short[0] > self.sma_long[0]:
            self.buy()
        elif self.sma_short[0] < self.sma_long[0]:
            self.sell()

# Crear el backtester
cerebro = bt.Cerebro()
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
cerebro.addstrategy(SmaCross)
cerebro.run()
cerebro.plot()

Este código verifica cómo se habría comportado la estrategia con los datos históricos.

6. Ejecución automática de órdenes

Ahora que la estrategia está probada, podemos automatizar el trading. Ejemplo de envío de una orden mediante la API de Binance:

api_key = "TU_API_KEY"
api_secret = "TU_API_SECRET"

exchange = ccxt.binance({
    'apiKey': api_key,
    'secret': api_secret
})

# Enviar una orden de compra de mercado para 0.01 BTC
order = exchange.create_market_buy_order('BTC/USDT', 0.01)
print(order)

7. Gestión de riesgos

Cuando escribes un bot de trading, es vital considerar la gestión del capital:

• Stop-loss fijos — Limitan las pérdidas.
• Trailing stop — Permite asegurar ganancias.
• Tamaño de la posición — Calcular el tamaño de la operación en función del capital disponible.

Ejemplo de código para calcular el tamaño de la operación (2% de riesgo):

capital = 10000  # Tamaño del capital
risk_per_trade = 0.02  # 2% de riesgo
stop_loss = 200  # Pérdida en caso de entrada incorrecta
trade_size = (capital * risk_per_trade) / stop_loss

print(f"Tamaño recomendado de la posición: {trade_size} USDT")

Conclusiones

Ahora tienes una comprensión básica de cómo escribir estrategias algorítmicas en Python: ✅ Obtención de datos a través de API
✅ Uso de indicadores técnicos
✅ Backtesting con datos históricos
✅ Ejecución automática de órdenes
✅ Gestión de riesgos

A partir de aquí, puedes ir complicando la estrategia, añadiendo machine learning, indicadores más complejos y optimización de parámetros.

Si te interesan temas más complejos como el market-making, HFT o estrategias de arbitraje, déjalos en los comentarios y los exploramos en el siguiente artículo. 🚀