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

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

In diesem Abschnitt zeige ich dir, wie du mit Python einen einfachen Trading-Bot programmieren kannst, der auf der SMA200 Long-Only Strategie basiert. 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:

• Eine Long-Position wird eröffnet, wenn der Schlusskurs an drei aufeinanderfolgenden Tagen über dem SMA200 liegt.

• Verkaufe, wenn der Schlusskurs an drei aufeinanderfolgenden Tagen unter den SMA200 fällt.

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

Warum der SMA200 als Indikator?

Der SMA200 ist einer der meistgenutzten gleitenden Durchschnitte im Trading. Er betrachtet die Schlusskurse der letzten 200 Tage und eignet sich deshalb ideal als Trendfilter.

Liegt der Kurs über dem SMA200, befindet sich der Markt im Aufwärtstrend. Fällt der Kurs darunter, signalisiert dies 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:

• yfinance: Zum Abrufen von Marktdaten

• plotly: Für die Visualisierung der Daten

• pandas: Zur Datenverarbeitung

• Der Code lädt tägliche Kursdaten für den Nasdaq 100 Index der letzten 31 Jahre.

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 soll kaufen, wenn der Kurs drei Tage hintereinander über dem SMA200 liegt und verkaufen, wenn der Kurs drei Tage hintereinander unter dem SMA200 liegt.

# 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:

• Candlestick-Chart des Nasdaq 100

• Rote Linie: Der SMA200 als Trendfilter

• Grüne Linie: Die Performance der Strategie

Die Grafik zeigt deutlich, dass unsere Long-Only-Strategie den Nasdaq 100 in der Performance übertrifft.

Mit dieser Strategie in Python, wollte ich dir zeigen, wie eine einfache und unkomplizierte Strategien erfolgreich eingesetzt werden können. Denke jedoch 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ärts- oder Bärenmärkten schneidet sie jedoch deutlich schlechter ab.