Algorithmischer Handel: Eigene Strategien mit Python schreiben

Algorithmischer Handel ist längst nicht mehr nur Hedgefonds und großen Marktteilnehmern vorbehalten. Dank Python und Open-Source-Bibliotheken kann heute jeder eigene Handelsstrategien entwickeln, den Prozess automatisieren und sogar ein profitables System erstellen. In diesem Artikel zeigen wir, wie man Handelsalgorithmen schreibt, welche Tools man nutzen sollte und wie man Strategien vor dem Live-Einsatz testet.

1. Warum Python?

Python ist die bevorzugte Sprache für den algorithmischen Handel aus mehreren Gründen:

• Einfache Syntax – erleichtert das schnelle Schreiben und Testen von Code.
• Umfangreiches Ökosystem – Bibliotheken für Datenverarbeitung, Analyse, maschinelles Lernen und API-Schnittstellen zu Börsen.
• Flexibilität – ermöglicht die Integration mit Brokern, Krypto-Börsen, Servern und Cloud-Lösungen.

Beliebte Bibliotheken für den algorithmischen Handel in Python:

• pandas – Datenanalyse und -verarbeitung.
• numpy – schnelle mathematische Berechnungen.
• ccxt – API-Anbindung an Krypto-Börsen.
• backtrader oder zipline – Strategie-Backtesting.
• ta – technische Indikatoren.

2. Architektur eines Handelsbots

Ein typischer algorithmischer Handelsbot besteht aus mehreren Modulen:

1. Datenbeschaffung
   • Abrufen von Preisdaten über API.
   • Speicherung der Daten im Cache oder einer Datenbank.
2. Datenanalyse
   • Berechnung von Indikatoren (SMA, RSI, MACD usw.).
   • Erkennung von Mustern und Trends.
3. Entscheidungsfindung
   • Entwicklung eines Algorithmus zur Identifikation von Ein- und Ausstiegspunkten.
   • Risikomanagement (Stop-Loss, Take-Profit).
4. Ausführung von Trades
   • Platzieren von Orders über die API.
   • Überwachung der Ausführung.
5. Logging und Monitoring
   • Aufzeichnung von Transaktionsdaten.
   • Erkennung von Fehlern und Anpassung der Strategie.

3. Verbindung zur Börse & Datenabruf

Verbindung zur Krypto-Börse Binance mit ccxt und Abruf historischer Daten:

import ccxt
import pandas as pd

# Verbindung zu Binance
exchange = ccxt.binance()

# Historische Daten für BTC/USDT abrufen
bars = exchange.fetch_ohlcv('BTC/USDT', timeframe='1h', limit=100)

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

print(df.tail())

Jetzt haben wir die Daten und können sie analysieren.

4. Entwicklung einer einfachen Strategie (SMA-Crossover)

Eine der einfachsten Strategien ist der Crossover zweier gleitender Durchschnitte (SMA). Wenn der kurze SMA den langen von unten nach oben kreuzt – kaufen, sonst verkaufen.

import numpy as np

# Berechnung der gleitenden Durchschnitte
df['SMA_50'] = df['close'].rolling(window=50).mean()
df['SMA_200'] = df['close'].rolling(window=200).mean()

# Signale generieren
df['signal'] = np.where(df['SMA_50'] > df['SMA_200'], 1, -1)

print(df.tail())

Die Spalte signal gibt an: 1 für Kauf, -1 für Verkauf.

5. Backtesting der Strategie

Bevor eine Strategie live geht, muss sie auf historischen Daten getestet werden. Hier mit 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()

# Backtest erstellen
cerebro = bt.Cerebro()
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
cerebro.addstrategy(SmaCross)
cerebro.run()
cerebro.plot()

Dieser Code zeigt, wie sich die Strategie auf vergangenen Daten verhalten hätte.

6. Automatisierte Orderausführung

Nach erfolgreichem Testen kann die Strategie automatisiert werden. Beispiel: Market-Order über die Binance-API senden:

api_key = "DEIN_API_KEY"
api_secret = "DEIN_API_SECRET"

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

# Market-Order für 0.01 BTC platzieren
order = exchange.create_market_buy_order('BTC/USDT', 0.01)
print(order)

7. Risikomanagement

Ein guter Handelsbot berücksichtigt auch Risikomanagement:

• Feste Stop-Losses – begrenzen Verluste.
• Trailing-Stop – sichert Gewinne.
• Positionsgröße – Berechnung des Handelsvolumens basierend auf dem Kapital.

Beispielcode für die Berechnung der Positionsgröße (2% Risiko pro Trade):

capital = 10000  # Kapitalgröße
risk_per_trade = 0.02  # 2% Risiko
stop_loss = 200  # Verlust bei Fehleinstieg
trade_size = (capital * risk_per_trade) / stop_loss

print(f"Empfohlene Positionsgröße: {trade_size} USDT")

Fazit

Jetzt hast du eine grundlegende Vorstellung davon, wie man algorithmische Handelsstrategien mit Python erstellt:
✅ Datenabruf über API
✅ Nutzung technischer Indikatoren
✅ Backtesting auf historischen Daten
✅ Automatische Orderausführung
✅ Risikomanagement

Als nächster Schritt kannst du deine Strategie weiterentwickeln, z. B. mit maschinellem Lernen, erweiterten Indikatoren oder Parameteroptimierung.

Falls du Interesse an komplexeren Themen hast, wie Market Making, HFT oder Arbitrage-Strategien – schreib es in die Kommentare, und wir behandeln sie im nächsten Artikel! 🚀