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.

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 gilt als wichtigster Trendfilter für die langfristige Marktrichtung.

Der SMA200 ist einer der meistgenutzten gleitenden Durchschnitte im Trading. Liegt der Kurs über dem SMA200, befindet sich der Markt im Aufwärtstrend. Fällt der Kurs darunter, signalisiert das potenzielle Schwäche.

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.

import yfinance as yf
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd

# Name des Index
ticker = "^NDX"

# Historische Daten der letzten 31 Jahre abrufen

start_date = (pd.to_datetime("today") - pd.DateOffset(years=31)).strftime('%Y-%m-%d')
end_date = pd.to_datetime("today").strftime('%Y-%m-%d')
nasdaq = yf.Ticker(ticker)
hist = nasdaq.history(start=start_date, end=end_date, interval='1d')

Erklärung:

Schritt 2: Berechnung des SMA200

Der SMA200 wird berechnet, indem der Durchschnitt der letzten 200 Schlusskurse gebildet wird.

# SMA200 berechnen
hist['SMA200'] = hist['Close'].rolling(window=200).mean()

Schritt 3: Kauf- und Verkaufsregeln definieren

Jetzt definieren wir die Regeln der Strategie. Der Bot kauft, wenn der Kurs drei Tage hintereinander über dem SMA200 liegt. Er verkauft, wenn der Kurs drei Tage hintereinander darunter schließt. Die Drei-Tage-Bestätigung filtert Fehlsignale an einzelnen Ausreißer-Tagen heraus.

# Variablen für die Trading-Strategie
initial_investment = 500
investment_value_strategy = initial_investment
position_opened = False
consecutive_days_above = 0
consecutive_days_below = 0
values_strategy = [initial_investment]

# Trading-Logik
for i in range(1, len(hist)):
    close_price = hist['Close'].iloc[i]
    sma200 = hist['SMA200'].iloc[i]

    # Bedingungen prüfen
    if close_price > sma200:
        consecutive_days_above += 1
        consecutive_days_below = 0
    else:
        consecutive_days_below += 1
        consecutive_days_above = 0

    # Kaufregel
    if consecutive_days_above >= 3 and not position_opened:
        position_opened = True
        entry_price = close_price

    # Verkaufsregel
    elif consecutive_days_below >= 3 and position_opened:
        position_opened = False

    # Investment aktualisieren, wenn Position offen
    if position_opened:
        daily_return = (close_price / hist['Close'].iloc[i-1]) - 1
        investment_value_strategy *= (1 + daily_return)

    # Wert speichern
    values_strategy.append(investment_value_strategy)

Schritt 4: Ergebnisvisualisierung mit Plotly

Um die Performance der Strategie sichtbar zu machen, verwenden wir die Bibliothek plotly für eine anschauliche Grafik.

# Daten in den DataFrame einfügen
hist['StrategyValue'] = values_strategy

# Visualisierung der Strategie
fig = make_subplots(specs=[[{"secondary_y": False}]])

# Candlestick-Chart für den Nasdaq 100
fig.add_trace(go.Candlestick(
    x=hist.index,
    open=hist['Open'],
    high=hist['High'],
    low=hist['Low'],
    close=hist['Close'],
    name='Nasdaq 100 (Candlestick)'
))

# SMA200 Linie
fig.add_trace(go.Scatter(
    x=hist.index,
    y=hist['SMA200'],
    marker_color='red',
    name='SMA200',
    line=dict(width=2)
))

# Strategie-Performance
fig.add_trace(go.Scatter(
    x=hist.index,
    y=hist['StrategyValue'],
    marker_color='green',
    name='Investment Strategy Value',
    line=dict(width=2)
))

# Layout anpassen
fig.update_layout(
    title={'text': 'Nasdaq 100, SMA200 Long-Only Strategie (3 Schlusskerzen)', 'x': 0.5},
    plot_bgcolor='white',
    paper_bgcolor='white',
    font=dict(color='black'),
    xaxis_rangeslider_visible=True
)

# X- und Y-Achsen anpassen
fig.update_xaxes(
    showgrid=True,
    color='black',
    rangebreaks=[dict(bounds=["sat", "mon"])]  # Wochenenden ausblenden
)
fig.update_yaxes(
    showgrid=True,
    color='black',
    title_text="Wert (USD)"
)

# Plot anzeigen
fig.show()

In der Grafik siehst du:

Die Grafik zeigt deutlich: Die Long-Only-Strategie übertrifft den Nasdaq 100 im Backtest. Mit diesem Beispiel wollte ich dir zeigen, dass auch ein einfaches Regelwerk funktionieren kann. Denk aber daran: Vergangene Performance ist kein Indikator für zukünftige Ergebnisse.

Die Strategie funktioniert besonders gut in Bullenmärkten, in denen der Aufwärtstrend stark ist. In Seitwärtsphasen oder Bärenmärkten schneidet sie deutlich schlechter ab.

Lesetipp: Mehr über Grid Trading erfahren

Schreibe mir ein Python-Skript, das mit yfinance die Tageskurse des
Nasdaq 100 der letzten 20 Jahre lädt, den SMA200 berechnet und eine
Long-Only-Strategie backtestet: Kauf nach 3 Schlusskursen über dem
SMA200, Verkauf nach 3 Schlusskursen darunter.
Visualisiere Kurs, SMA200 und Strategie-Performance mit plotly.