Trading Algorithmique : Comment créer vos propres stratégies avec Python

Le trading algorithmique n’est plus réservé aux hedge funds et aux gros acteurs du marché. Grâce à Python et à ses bibliothèques open source, tout le monde peut concevoir ses propres stratégies de trading, automatiser le processus et même créer un système rentable. Dans cet article, nous verrons comment coder des algorithmes de trading, quels outils utiliser et comment tester une stratégie avant de la lancer sur les marchés.

1. Pourquoi choisir Python ?

Python est le langage de référence pour le trading algorithmique, et ce, pour plusieurs raisons :

• Simplicité du code – Il permet d’écrire et de tester rapidement des stratégies.
• Écosystème riche – De nombreuses bibliothèques pour l’analyse de données, l’apprentissage automatique et l’intégration avec les API des plateformes de trading.
• Flexibilité – Compatible avec les courtiers, les exchanges crypto, les serveurs cloud et les solutions d’exécution automatique.

Voici quelques bibliothèques Python incontournables pour le trading :

• pandas – Manipulation et analyse des données.
• numpy – Calculs mathématiques avancés.
• ccxt – Connexion aux exchanges via API.
• backtrader ou zipline – Backtesting des stratégies.
• ta – Indicateurs d’analyse technique.

2. Architecture d’un bot de trading

Un bot de trading algorithmique suit une structure modulaire bien définie :

1. Récupération des données
   • Accès aux prix en temps réel via l’API d’un exchange.
   • Stockage des données en cache ou en base de données.
2. Analyse des données
   • Calcul des indicateurs techniques (SMA, RSI, MACD, etc.).
   • Détection des tendances et des figures chartistes.
3. Prise de décision
   • Définition des règles d’entrée et de sortie de position.
   • Gestion des risques (stop-loss, take-profit).
4. Exécution des ordres
   • Envoi des ordres via API.
   • Suivi de l’exécution et gestion des erreurs.
5. Monitoring et journalisation
   • Enregistrement des transactions.
   • Suivi des performances et ajustement des stratégies.

3. Connexion à un exchange et récupération des données

Connectons-nous à Binance via ccxt pour récupérer des données historiques :

import ccxt
import pandas as pd

# Connexion à Binance
exchange = ccxt.binance()

# Récupération des données OHLCV pour BTC/USDT
bars = exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100)

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

print(df.tail())

Nous avons maintenant un historique des prix que nous pouvons analyser.

4. Implémentation d’une stratégie simple (croisement de moyennes mobiles)

Une des stratégies les plus basiques consiste à utiliser un croisement de moyennes mobiles (SMA). Lorsqu’une SMA courte croise une SMA longue à la hausse, on achète. Lorsqu’elle la croise à la baisse, on vend.

Voici comment l’implémenter en Python :

import numpy as np

# Calcul des moyennes mobiles
df['SMA_50'] = df['close'].rolling(window=50).mean()
df['SMA_200'] = df['close'].rolling(window=200).mean()

# Génération des signaux d'achat et de vente
df['signal'] = np.where(df['SMA_50'] > df['SMA_200'], 1, -1)

print(df.tail())

Nous obtenons une colonne signal où 1 signifie acheter et -1 vendre.

5. Backtesting de la stratégie

Avant de déployer une stratégie, il est crucial de tester ses performances sur des données historiques. Voici comment le faire avec 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()

# Création du backtester
cerebro = bt.Cerebro()
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
cerebro.addstrategy(SmaCross)
cerebro.run()
cerebro.plot()

Ce code simule l’exécution de la stratégie sur des données passées pour évaluer ses performances.

6. Automatisation de l’exécution des ordres

Une fois la stratégie testée, nous pouvons automatiser le passage des ordres via l’API de Binance :

api_key = "VOTRE_API_KEY"
api_secret = "VOTRE_API_SECRET"

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

# Passer un ordre d'achat au prix du marché pour 0.01 BTC
order = exchange.create_market_buy_order('BTC/USDT', 0.01)
print(order)

7. Gestion des risques

Un bon bot de trading doit inclure des règles strictes de gestion des risques :

• Stop-loss fixes – Limiter les pertes sur chaque trade.
• Trailing stop – Sécuriser les gains en ajustant le stop-loss dynamiquement.
• Taille des positions – Adapter la taille des ordres en fonction du capital disponible.

Exemple de calcul de la taille d’une position en fonction d’un risque de 2 % :

capital = 10000  # Capital total en USDT
risk_per_trade = 0.02  # Risque de 2 % par trade
stop_loss = 200  # Perte potentielle en USDT si le trade est perdant
trade_size = (capital * risk_per_trade) / stop_loss

print(f"Taille recommandée de la position : {trade_size} USDT")

Conclusion

Vous avez maintenant une bonne compréhension de la construction d’un bot de trading en Python :
✅ Récupération des données via API
✅ Utilisation d’indicateurs techniques
✅ Backtesting sur données historiques
✅ Exécution automatisée des ordres
✅ Gestion des risques

Les prochaines étapes ? Expérimenter des stratégies plus complexes, intégrer du machine learning, ou encore optimiser les paramètres pour maximiser les gains.

Si vous souhaitez explorer d’autres sujets comme le market making, le HFT ou l’arbitrage, laissez un commentaire et on en parlera dans un prochain article ! 🚀