Python Trading Bot: Einfache Schritt-für-Schritt-Anleitung für Algo-Trading (2026)

Python Trading Bot programmieren: Schritt-für-Schritt-Anleitung

In diesem Abschnitt zeige ich dir, wie du mit Python einen einfachen Trading-Bot programmierst, der auf der SMA200 Long-Only-Strategie basiert. Long-Only heißt: Der Bot kauft nur und verkauft nie leer. Wir gehen den Code Schritt für Schritt durch, damit du ihn verstehst und direkt selbst umsetzen kannst.

Setup: Python-Umgebung einrichten

Bevor der Code läuft, brauchst du eine Python-Umgebung. Dieser Artikel wurde ausschließlich mit Python 3.13 getestet; andere Versionen sind nicht verifiziert und können abweichendes Verhalten zeigen. Die folgenden Zeilen funktionieren unter macOS und Linux; unter Windows aktivierst du die Umgebung in PowerShell mit .\.venv\Scripts\Activate.ps1:

python3 -m venv .venv
source .venv/bin/activate
pip install yfinance pandas matplotlib

Lege eine Datei namens sma200_bot.py an und speichere die vier Code-Blöcke weiter unten in dieser Reihenfolge dort hinein. Starte sie mit python3 sma200_bot.py. Die erwartete Ausgabe nennt den Daten-Bezugszeitraum, die Anzahl der Trades sowie Rendite und maximalen Drawdown für Strategie und Vergleichslinie Kaufen-und-Halten. Das Skript schreibt zusätzlich eine trades.csv mit allen Transaktionen und einen Chart sma200_vergleich.png. Wenn Yahoo Finance mit HTTP 429 antwortet, wiederhole den Lauf nach einigen Minuten. Für einen reproduzierbaren Lauf aus einem lokalen Cache akzeptiert Block 1 die Umgebungsvariable NDX_CSV: speichere einen erfolgreichen Download einmalig per hist.to_csv("ndx.csv") und starte spätere Läufe mit NDX_CSV=ndx.csv python3 sma200_bot.py. Nimm nicht einfach ein anderes Zeitfenster, sonst passt das Ergebnis nicht mehr zum Rest des Artikels. Mehr zu Umgebungen findest du in der offiziellen venv-Dokumentation.

Was der Code modelliert und was nicht: ein hypothetisches, bruchteilbares Positions-Konto am Nasdaq-100-Index. Der Index selbst ist nicht handelbar, es gibt keine Entsprechung mit identischen Kosten. Dividenden, Spreads, Steuern und Finanzierungs- oder Cash-Zinsen werden NICHT modelliert. Die Transaktionsgebühr FEE_RATE ist eine illustrative Annahme (5 Basispunkte), kein nachgewiesener ETF-Preis. Teileinheiten mit sechs Nachkommastellen vereinfachen die Buchführung; je nach Instrument und Broker handelst du ganze Einheiten (z. B. ein Futures-Kontrakt) oder bruchteilige (viele Krypto-Börsen und einige Aktienbroker für fractional shares). Die Endpunkt-Liquidation am letzten Handelstag ist eine vordeklarierte Backtest-Annahme, kein Strategiesignal. Benchmark und Strategie bekommen dieselbe Gebühr.

Was macht der Code?

Dieser Bot folgt einer Trendfolge-Strategie mit dem SMA200 (Simple Moving Average). Die Idee ist, langfristige Aufwärtstrends im Markt zu nutzen und klare Regeln für Käufe und Verkäufe festzulegen:

Der Fokus liegt auf einem sehr einfachen Regelwerk, das sich leicht nachvollziehen lässt. Genau richtig für den Einstieg ins Algo-Trading.

Warum der SMA200 als Indikator?

Der SMA200 ist der einfache gleitende Durchschnitt der letzten 200 Schlusskurse. Er ist ein verbreiteter langfristiger Trendfilter.

Der SMA200 ist einer der meistgenutzten gleitenden Durchschnitte im Trading. Liegt der Kurs über dem SMA200, erfüllt er das Einstiegskriterium dieser Strategie. Fällt er darunter, signalisiert das potenzielle Schwäche; einen intakten Trend beweist die Lage zur SMA200 allein jedoch nicht. Die drei-Tage-Bestätigung kann kurze Fehlsignale abfangen, verzögert aber jeden Entry und Exit; ob sie das Ergebnis verbessert, zeigt der Backtest.

Schritt 1: Bibliotheken importieren und Daten abrufen

Zuerst importieren wir die benötigten Python-Bibliotheken und laden die historischen Kursdaten für den Nasdaq 100 aus Yahoo Finance. Als Testfenster nehmen wir den 1. Januar 2007 bis 2. Oktober 2026. Die SMA braucht die ersten 200 Handelstage zum Warmlaufen; der Backtest startet effektiv Mitte Oktober 2007.

# === BLOCK 1 ===
# Schritt 1: Bibliotheken importieren und Daten vorbereiten
import csv
import math
import os

import numpy as np
import pandas as pd
import yfinance as yf

TICKER = "^NDX"
START = "2007-01-01"
END = "2026-10-03"  # exklusiv
INITIAL_CASH = 500.0
FEE_RATE = 0.0005  # 5 Basispunkte je Transaktion (illustrative Annahme)
CONFIRM = 3
WINDOW = 200

CSV_CACHE = os.environ.get("NDX_CSV")  # optional: lokaler CSV-Pfad fuer offline-Lauf
if CSV_CACHE:
    hist = pd.read_csv(CSV_CACHE, index_col=0, parse_dates=True)
else:
    hist = yf.download(
        TICKER, start=START, end=END, interval="1d",
        auto_adjust=False, actions=False, progress=False, threads=False,
    )
    if isinstance(hist.columns, pd.MultiIndex):
        hist.columns = [c[0] for c in hist.columns]

if getattr(hist.index, "tz", None) is not None:
    hist.index = hist.index.tz_localize(None)

Erklärung:

Schritt 2: Berechnung des SMA200

Der SMA200 wird berechnet, indem der Durchschnitt der letzten 200 Schlusskurse gebildet wird. Mit min_periods=200 bleibt die SMA während des Warm-ups bewusst leer, damit kein Signal auf halben Daten entsteht.

# === BLOCK 2 ===
# Schritt 2: Datenvalidierung (ohne stilles Droppen) UND SMA200 berechnen
def _validate(df, min_window):
    """Lehnt empty, missing-column, NaN, unsortiert, Dubletten, OHLC-Verletzung ab.

    Prueft nur die vier Pflichtspalten (Open/High/Low/Close); evtl. zusaetzliche
    Spalten (z. B. Volume aus yfinance) werden ignoriert, aber nicht entfernt.
    """
    if df.empty:
        raise ValueError("Leerer Datensatz: Daten konnten nicht geladen werden.")
    required = {"Open", "High", "Low", "Close"}
    missing = required - set(df.columns)
    if missing:
        raise ValueError(f"Fehlende Spalten im Datensatz: {sorted(missing)}")
    if not df.index.is_monotonic_increasing:
        raise ValueError("Zeitreihe ist nicht aufsteigend sortiert.")
    if df.index.duplicated().any():
        raise ValueError("Zeitreihe enthaelt doppelte Zeitstempel.")
    for col in sorted(required):
        v = df[col].astype(float)
        if not np.isfinite(v).all():
            raise ValueError(f"Spalte {col} enthaelt nicht-endliche Werte.")
        if (v <= 0).any():
            raise ValueError(f"Spalte {col} enthaelt nicht-positive Werte.")
    o = df["Open"].astype(float)
    h = df["High"].astype(float)
    l_ = df["Low"].astype(float)
    c = df["Close"].astype(float)
    if ((h < o) | (h < c)).any():
        raise ValueError("OHLC-Verletzung: High < max(Open, Close).")
    if ((l_ > o) | (l_ > c)).any():
        raise ValueError("OHLC-Verletzung: Low > min(Open, Close).")
    if (h < l_).any():
        raise ValueError("OHLC-Verletzung: High < Low.")
    if len(df) < min_window + 1:
        raise ValueError(f"Datensatz zu kurz: {len(df)} < {min_window + 1}.")


_validate(hist, min_window=WINDOW)
hist["SMA200"] = hist["Close"].rolling(window=WINDOW, min_periods=WINDOW).mean()

Schritt 3: Kauf- und Verkaufsregeln sauber buchen

Jetzt definieren wir die Regeln der Strategie. Wichtig: Das Signal entsteht am Schluss des dritten bestätigten Tages, die Ausführung simulieren wir zum nächsten Eröffnungskurs. Position, Cash und Equity werden täglich zum Close bewertet. Equality bricht die Serie, fehlende SMA-Werte zählen nicht als Signal.

# === BLOCK 3 ===
# Schritt 3: Signal, Fill, Buchfuehrung, Endpunkt-Liquidation
close_ok = hist["Close"].notna()
sma_ok = hist["SMA200"].notna()
valid = close_ok & sma_ok

above = (hist["Close"] > hist["SMA200"]) & valid
below = (hist["Close"] < hist["SMA200"]) & valid


def _consec(mask):
    groups = (~mask).cumsum()
    return mask.astype(int).groupby(groups).cumsum()


entry_signal = (_consec(above) >= CONFIRM).to_numpy()
exit_signal = (_consec(below) >= CONFIRM).to_numpy()

cash = INITIAL_CASH
units = 0.0
equity = []
held_before_eod = []
trades = []  # (signal_date, fill_date, side, price, size, fee, reason)

for i, ts in enumerate(hist.index):
    today_open = float(hist["Open"].iloc[i])
    if i > 0:
        if units == 0.0 and entry_signal[i - 1]:
            size = math.floor(cash / (today_open * (1 + FEE_RATE)) * 1e6) / 1e6
            if size > 0:
                cost = size * today_open
                fee = cost * FEE_RATE
                cash -= cost + fee
                units += size
                trades.append((hist.index[i - 1], ts, "BUY", today_open, size, fee,
                               f"{CONFIRM} Closes > SMA{WINDOW}"))
        elif units > 0.0 and exit_signal[i - 1]:
            proceeds = units * today_open
            fee = proceeds * FEE_RATE
            cash += proceeds - fee
            trades.append((hist.index[i - 1], ts, "SELL", today_open, units, fee,
                           f"{CONFIRM} Closes < SMA{WINDOW}"))
            units = 0.0
    held_before_eod.append(units > 0.0)
    equity.append(cash + units * float(hist["Close"].iloc[i]))

# Endpunkt-Liquidation (vordeklariert, kein Signal)
if units > 0.0:
    last_close = float(hist["Close"].iloc[-1])
    proceeds = units * last_close
    fee = proceeds * FEE_RATE
    cash += proceeds - fee
    trades.append((hist.index[-1], hist.index[-1], "SELL_END", last_close, units, fee,
                   "Endpunkt-Liquidation (vordeklarierte Backtest-Annahme, kein Signal)"))
    units = 0.0
    equity[-1] = cash

hist["Equity"] = equity

Schritt 4: Ergebnis anzeigen und ehrlich einordnen

Zur Auswertung zeichnen wir zwei Charts: einen Depotvergleich zwischen Strategie und Kaufen-und-Halten (gleiches Startkapital) und darunter die zugehörigen Drawdowns.

# === BLOCK 4 ===
# Schritt 4: Benchmark Kaufen-und-Halten mit identischer Gebuehr, Metriken, Konsolen-Summary
first_valid = int(valid.to_numpy().argmax())
bh_entry = float(hist["Open"].iloc[first_valid])
bh_size = math.floor(INITIAL_CASH / (bh_entry * (1 + FEE_RATE)) * 1e6) / 1e6
bh_cash_after_entry = INITIAL_CASH - bh_size * bh_entry * (1 + FEE_RATE)
bh = [float("nan")] * first_valid
for j in range(first_valid, len(hist)):
    bh.append(bh_cash_after_entry + bh_size * float(hist["Close"].iloc[j]))
last_close = float(hist["Close"].iloc[-1])
bh[-1] = bh_cash_after_entry + bh_size * last_close * (1 - FEE_RATE)
hist["BuyAndHold"] = bh

eval_start = hist.index[first_valid]
eval_end = hist.index[-1]
days = (eval_end - eval_start).days
years = days / 365.25


def _ann(total):
    return (1 + total) ** (1 / years) - 1 if years > 0 else float("nan")


def _max_dd(curve):
    # Peak = beobachtetes Hoch, mindestens Startkapital. Erster Wert wird NICHT
    # ueberschrieben, sonst wuerde ein Erst-Tag unter Startkapital unsichtbar.
    peak = curve.cummax().clip(lower=INITIAL_CASH)
    return float((curve / peak - 1.0).min())


strat_curve = hist["Equity"].iloc[first_valid:]
bh_curve = hist["BuyAndHold"].iloc[first_valid:]
strat_total = float(strat_curve.iloc[-1]) / INITIAL_CASH - 1
bh_total = float(bh_curve.iloc[-1]) / INITIAL_CASH - 1
exposure = sum(held_before_eod[first_valid:]) / len(held_before_eod[first_valid:])

print(f"Zeitraum: {eval_start.date()} bis {eval_end.date()} ({days} Tage, Warm-up ausgeschlossen)")
print(f"Strategie Endstand: {strat_curve.iloc[-1]:.2f} USD  "
      f"({strat_total*100:.2f} %, {_ann(strat_total)*100:.2f} % p.a., Max-DD {_max_dd(strat_curve)*100:.2f} %)")
print(f"Kaufen-und-Halten:   {bh_curve.iloc[-1]:.2f} USD  "
      f"({bh_total*100:.2f} %, {_ann(bh_total)*100:.2f} % p.a., Max-DD {_max_dd(bh_curve)*100:.2f} %)")
print(f"Trades: {sum(1 for t in trades if t[2]=='BUY')} Entries, "
      f"{sum(1 for t in trades if t[2]=='SELL')} Signal-Exits, "
      f"{sum(1 for t in trades if t[2]=='SELL_END')} Endpunkt-Liquidation; "
      f"Exposure {exposure*100:.1f} % der Evaluierungstage")

# Transaktionslog mit csv.writer; Reasons koennen Kommas enthalten (SELL_END).
with open("trades.csv", "w", newline="") as fh:
    writer = csv.writer(fh, quoting=csv.QUOTE_MINIMAL)
    writer.writerow(["signal_date", "fill_date", "side", "price", "size", "fee", "reason"])
    for sig, fill, side, price, size, fee, reason in trades:
        writer.writerow([
            sig.date().isoformat(),
            fill.date().isoformat(),
            side,
            f"{price:.4f}",
            f"{size:.6f}",
            f"{fee:.6f}",
            reason,
        ])
print("Transaktionen gespeichert: trades.csv")

# Chart: Depotverlauf gegen Kaufen-und-Halten mit Drawdown-Panel.
import matplotlib
matplotlib.use("Agg")  # headless, keine GUI
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker

dd_s = strat_curve / strat_curve.cummax().clip(lower=INITIAL_CASH) - 1.0
dd_bh = bh_curve / bh_curve.cummax().clip(lower=INITIAL_CASH) - 1.0

fig, (ax1, ax2) = plt.subplots(
    2, 1, figsize=(10, 6.6),
    gridspec_kw={"height_ratios": [3, 1.3], "hspace": 0.14},
    sharex=True,
)
ax1.plot(strat_curve.index, strat_curve, color="#0052FF", linewidth=1.9,
         label=f"SMA200-Strategie (Endstand {strat_curve.iloc[-1]:.0f} USD)")
ax1.plot(bh_curve.index, bh_curve, color="#5B616E", linewidth=1.6,
         label=f"Kaufen und Halten (Endstand {bh_curve.iloc[-1]:.0f} USD)")
ax1.set_yscale("log")
ax1.set_ylabel("Depot in USD (Log-Skala)")
ax1.set_title(f"Depotverlauf bei {INITIAL_CASH:.0f} USD Startkapital, {eval_start.date()} bis {eval_end.date()}",
              fontsize=12, loc="left")
ymin = min(strat_curve.min(), bh_curve.min()) * 0.8
ymax = max(strat_curve.max(), bh_curve.max()) * 1.15
ax1.set_ylim(ymin, ymax)
ax1.yaxis.set_major_locator(mticker.FixedLocator([200, 500, 1000, 2000, 5000, 10000]))
ax1.yaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f"{int(x):,}".replace(",", ".")))
ax1.yaxis.set_minor_locator(mticker.NullLocator())
ax1.legend(loc="upper left", fontsize=8.5)
ax1.grid(True, alpha=0.25)

ax2.fill_between(dd_s.index, dd_s * 100, 0, color="#0052FF", alpha=0.35,
                 label=f"DD Strategie (max {dd_s.min()*100:.1f} %)")
ax2.fill_between(dd_bh.index, dd_bh * 100, 0, color="#5B616E", alpha=0.35,
                 label=f"DD B&H (max {dd_bh.min()*100:.1f} %)")
ax2.set_ylabel("Drawdown in %")
ax2.legend(loc="lower right", fontsize=8.5)
ax2.grid(True, alpha=0.25)

fig.autofmt_xdate()
fig.savefig("sma200_vergleich.png", dpi=150, bbox_inches="tight")
plt.close(fig)
print("Chart gespeichert: sma200_vergleich.png")

Was zeigt der Backtest? Im Evaluierungsfenster vom 17. Oktober 2007 bis zum 2. Oktober 2026 wächst das Strategie-Depot von 500 USD netto auf 3.946 USD. Das sind rund 689 Prozent Gesamtrendite oder 11,5 Prozent pro Jahr bei einem maximalen Drawdown von 28,5 Prozent. Der Kaufen-und-Halten-Vergleich mit identischen Gebühren endet bei 7.050 USD, also 1.310 Prozent Gesamtrendite oder 15,0 Prozent pro Jahr bei einem maximalen Drawdown von 53,7 Prozent. Ohne Gebühr („gross“) sind es für die Strategie 710 Prozent, für die Vergleichslinie 1.311 Prozent. Die Gebührenannahme verschiebt die Zahlen, dreht das Vorzeichen aber nicht. Die Strategie schnitt in diesem Fenster also schlechter ab als die Vergleichslinie, hielt den maximalen Verlust aber etwa halb so klein. Insgesamt wurden 26 Entries, 25 Signal-Exits und eine Endpunkt-Liquidation ausgelöst, die Position war an 79,9 Prozent der Evaluierungstage investiert (vor der Endpunkt-Liquidation gezählt).

Mit diesem Beispiel wollte ich dir zeigen, dass sich ein einfaches Regelwerk vollständig nachvollziehen und messen lässt. Es belegt auch, warum eine Behauptung wie „schlägt den Index“ ohne Zahlen wenig wert ist. Vergangene Performance ist kein Indikator für zukünftige Ergebnisse. Warum dazu ein Out-of-Sample-Test gehört, zeigt das Backtesting-Beispiel mit 32 Jahren DAX.

Der Nasdaq 100 ist selbst nicht handelbar; ein Live-Pendant wäre ein ETF, ein Futures-Kontrakt oder ein CFD mit eigenen Kosten, Dividenden und Steuern. In Bullenmärkten, in denen der Aufwärtstrend stark ist, bleibt die Strategie meist voll investiert und zeigt kaum Vorteil gegenüber Kaufen-und-Halten. In Seitwärtsphasen oder Bärenmärkten kann der Filter einen Teil eines Rückgangs auslassen; dafür zahlst du mit verzögerten Einstiegen und Whipsaws, wenn der Markt knapp um den Durchschnitt pendelt.

Lesetipp: Mehr über Grid Trading erfahren