Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 9): External Flow

Einführung

Die Finanzmärkte können sehr komplex sein und stellen Händler und Analysten oft vor die Herausforderung, Daten korrekt zu verarbeiten und zu interpretieren. Zur Bewältigung dieser Herausforderungen wurden verschiedene Bibliotheken zur Vereinfachung der Marktanalyse entwickelt, die jeweils so konzipiert sind, dass sie Daten auf eine Weise verarbeiten, die auf bestimmte Ziele ausgerichtet ist. Während die MQL5-Bibliotheken üblicherweise zur Erstellung von Handelsstrategien und Indikatoren verwendet werden, bieten externe Bibliotheken, wie die Datenanalysetools von Python, zusätzliche Ressourcen für fortgeschrittene und tiefgreifende Analysen.

In früheren Artikeln habe ich mich auf Preisaktionen und Datenanalysen konzentriert und dabei vor allem die Signalerzeugung durch Berechnungen und Metriken untersucht, die von MQL5 Expert Advisors (EAs) verarbeitet werden. Diese Artikel beschränkten sich jedoch auf MQL5-basierte Analysen. Dieser Artikel markiert einen Wandel, indem er die Integration externer Bibliotheken vorstellt, die speziell für die erweiterte Datenanalyse entwickelt wurden. Durch den Einsatz der Python-Bibliothek Pandas können wir neue Wege für Händler erschließen und ein breiteres Spektrum an Analyseoptionen für verschiedene Bedürfnisse anbieten.

Diese Methode ersetzt nicht MQL5, sondern positioniert es als Kernstück dieses Systems. Die MQL5 EA dient als Brücke, die die Interaktion mit externen Bibliotheken und Servern ermöglicht, um einen robusteren und flexibleren analytischen Rahmen zu schaffen. Ich möchte betonen, dass dieser Artikel nur der Anfang der Erforschung fortgeschrittener Analysen ist, und ich freue mich darauf, in zukünftigen Diskussionen umfassendere Einblicke und Techniken zu präsentieren.

Schauen wir uns an, wie wir diese Aufgabe angehen werden:

• Überblick über die Strategie
• Python
• Hauptfunktionen des MQL5 EA
• Ergebnisse
• Schlussfolgerung

Überblick über die Strategie

Das Hauptziel dieses Systems ist die Generierung von Handelssignalen mit Hilfe der Pandas-Bibliothek von Python, wobei deren Dateninterpretationsfunktionen genutzt werden. In diesem Abschnitt werden wir einen genaueren Blick darauf werfen, wie die Kernlogik vom System ausgeführt wird. Der gesamte Austausch findet zwischen dem MQL5 Expert Advisor (EA) und Python statt, wobei verschiedene Prozesse dazwischen ablaufen, bevor das Signal schließlich auf dem Chart angezeigt wird. Folgen Sie den nachstehenden Schritten, um zu verstehen, wie das System funktioniert.

1. MQL5 EA zu Python:

• Der MQL5 Expert Advisor sammelt die Höchst-, Tiefst-, Eröffnungs- und Schlusskurse sowie das Volumen von den letzten 10 Tagen. 
• Senden der Daten an den Python Server. 
• Formatieren der Daten in eine CSV-Zeichenfolge und senden über eine HTTP-POST-Anfrage an den Python-Server.

2. Python:

• Python empfängt Daten und verarbeitet die empfangenen Daten mit Hilfe von Bibliotheken wie Pandas. 
• Datenanalyse, um ein Handelssignal, einen Durchschnittspreis und ein Volumen zu erzeugen, und Erstellen einer Erklärung danach.

3. Python an EA:

• Python sendet das generierte Signal, den Durchschnittspreis, das Volumen und die Erklärung per HTTP-Antwort zurück an den MQL5 EA.

4. MQL5 Expert Advisor:

• Der MQL5 EA empfängt und analysiert die Antwort, extrahiert Signal, Durchschnittspreis, Durchschnittsvolumen und Erklärung aus der Antwort. 
• Wenn das Signal anders ist, aktualisieren wir das Chart mit dem neuen Signal und zeigen es an.

Das folgende Diagramm bietet einen besseren Einblick.

Abb. 1. logisches Diagramm

Python

Python ist eine vielseitige Programmiersprache, die für ihre Einfachheit und ihr breites Spektrum an Anwendungen bekannt ist. Es wird unter anderem für Datenanalyse, maschinelles Lernen, Webentwicklung und Automatisierung eingesetzt. In diesem System ist Python von entscheidender Bedeutung für die Durchführung fortgeschrittener Datenanalysen, insbesondere durch Bibliotheken wie Pandas, die effiziente Werkzeuge für die Manipulation und Analyse von Daten bieten. Python erstellt auch einen Server für die Interaktion zwischen MQL5 und seinen Bibliotheken. Durch die Verwendung von Python zur Verarbeitung komplexer Datensätze erzeugt das System Handelssignale auf der Grundlage historischer Marktdaten, die dann an den MQL5 Expert Advisor (EA) weitergeleitet werden, um bei Live-Handelsentscheidungen zu helfen. 

Ich werde Sie Schritt für Schritt durch die Installation von Python, die Erstellung eines Skripts und dessen Ausführung führen.

• Laden Sie den Python Installer von der offiziellen Python Website herunter.
•  Starten Sie das Installationsprogramm

Das ist wichtig: Vergewissern Sie sich, dass das Kästchen „Python zu PATH hinzufügen“ aktiviert ist, bevor Sie auf Jetzt installieren klicken. Das macht es einfacher, Python von der Kommandozeile aus zu starten.

•  Fertigstellung der Installation

Das Installationsprogramm beginnt mit dem Installationsvorgang. Warten Sie, bis es zu Ende ist. Wenn die Installation abgeschlossen ist, klicken Sie auf Schließen.

•  Überprüfen Sie die Installation

Öffnen Sie die Eingabeaufforderung (drücken Sie Windows + R, geben Sie cmd ein, und drücken Sie die Eingabetaste). Geben Sie python --version ein und drücken Sie Enter. Wenn Python korrekt installiert ist, sollte die Python-Version angezeigt werden (z. B. Python 3.x.x).

Nach erfolgreicher Installation von Python sollten Sie nun Flask und Pandas installieren. Flask ist ein leichtgewichtiges Web-Framework für Python, mit dem sich Webanwendungen erstellen lassen. Es ist so konzipiert, dass es einfach, flexibel und leicht zu bedienen ist. Flask wird verwendet, um einen einfachen Webserver einzurichten, der die Kommunikation zwischen dem MQL5 Expert Advisor (EA) und den Python-Datenanalysetools ermöglicht. Der EA sendet Daten an Flask (über HTTP-Anfragen), das die Daten mithilfe von Python-Bibliotheken, in diesem Fall Pandas, verarbeitet und ein Handelssignal an den EA zurückgibt.

Um Flask und Pandas über die Eingabeaufforderung zu installieren, gehen Sie wie folgt vor:

Öffnen der Eingabeaufforderung

• Drücken Sie Windows + R, geben Sie cmd ein, und drücken Sie die Eingabetaste.

Sicherstellen, dass pip (Python Package Installer) installiert ist

• Prüfen Sie zunächst, ob pip (der Paketmanager von Python) installiert ist, indem Sie pip ausführen:

pip --version

• Wenn pip installiert ist, sehen Sie die Versionsnummer. Wenn es nicht installiert ist, können Sie die folgenden Schritte ausführen, um es zu installieren. PIP (Python Package Installer) wird normalerweise automatisch mit Python installiert. Wenn PIP nicht installiert ist, laden Sie get-pip.py herunter und starten Sie es mit dem Befehl python get-pip.py.

Flask installieren

• Um Flask zu installieren, führen Sie den folgenden Befehl in der Eingabeaufforderung aus:

pip install Flask

• Warten Sie auf die Fertigstellung der Installation. Flask ist nun installiert und einsatzbereit.

Pandas installieren

• Um Pandas zu installieren, führen Sie diesen Befehl aus:

pip install pandas

• Warten Sie ebenfalls, bis die Installation abgeschlossen ist.

Überprüfen der Installation

• Nachdem Sie beide Pakete installiert haben, können Sie die Installation mit diesen Befehlen überprüfen:

python -c "import flask; print(flask.__version__)"

python -c "import pandas; print(pandas.__version__)"

• Dies sollte die installierten Versionen von Flask und Pandas ausgeben und bestätigen, dass sie erfolgreich installiert wurden.

Sie können nun ein Python-Skript erstellen. Ich persönlich ziehe es vor, Notepad++ für diese Aufgabe zu verwenden. Um das Skript zu erstellen, öffnen Sie Notepad++, beginnen Sie eine neue Datei und stellen Sie die Sprache Python ein, indem Sie sie aus dem Menü Sprache auswählen. Wenn Sie Ihr Skript geschrieben haben, speichern Sie es in einem Verzeichnis, das leicht zu finden ist. Achten Sie darauf, die Datei mit der Erweiterung .py zu speichern, die sie als Python-Skript kennzeichnet.

Python-Skript

import pandas as pd
import flask
from flask import request, jsonify

app = flask.Flask(__name__)
app.config["DEBUG"] = True

@app.route('/analyze', methods=['POST'])
def analyze_csv():
    try:
        # Read CSV data from the POST request
        csv_data = request.data.decode('utf-8')

        # Write the CSV data to a file (optional, for debugging)
        with open('received_data.csv', 'w') as file:
            file.write(csv_data)

        # Load the CSV data into a DataFrame
        from io import StringIO
        data = StringIO(csv_data)
        df = pd.read_csv(data)

        # Ensure the CSV has the correct columns
        required_columns = ['date', 'prev_high', 'prev_low', 'prev_open', 'prev_close', 'prev_volume']
        for column in required_columns:
            if column not in df.columns:
                return jsonify({"error": f"Missing column: {column}"}), 400

        # Print the received metrics for debugging
        print("Received metrics:")
        print(df)

        # Perform analysis (Example: Calculate average price and volume)
        df['average_price'] = (df['prev_high'] + df['prev_low'] + df['prev_open'] + df['prev_close']) / 4
        average_price = df['average_price'].mean()  # Average of all the average prices
        average_volume = df['prev_volume'].mean()  # Average volume

        # Print the computed averages
        print(f"Average Price: {average_price}")
        print(f"Average Volume: {average_volume}")

        # Create a trading signal based on a simple rule
        last_close = df['prev_close'].iloc[-1]
        if last_close > average_price:
            signal = "BUY"
            signal_explanation = f"The last close price ({last_close}) is higher than the average price ({average_price})."
        else:
            signal = "SELL"
            signal_explanation = f"The last close price ({last_close}) is lower than the average price ({average_price})."

        # Print the signal and explanation
        print(f"Generated Signal: {signal}")
        print(f"Signal Explanation: {signal_explanation}")

        # Return the signal as JSON
        return jsonify({
            "signal": signal,
            "average_price": average_price,
            "average_volume": average_volume,
            "signal_explanation": signal_explanation
        })

    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    app.run(host='189.7.6.8', port=5877)

Um das Skript auszuführen, öffnen Sie die Eingabeaufforderung auf Ihrem Computer.

Führen Sie den Befehl aus:

cd C:\Users\pathway to your python script folder

Gefolgt von einem Befehl:

python filename.py

Verwenden Sie bei der Ausführung des Skripts den genauen Namen, den Sie ihm gegeben haben. Sobald das Skript läuft, zeigt es an, dass der Anschluss aktiv abgehört wird.

 Running on http://189.7.6.8:5877

Hauptfunktionen

Initialisierung (OnInit)

Diese Funktion wird ausgeführt, wenn der EA zum ersten Mal in der MetaTrader-Plattform initialisiert wird. Sie wird verwendet, um alle vom EA benötigten Ressourcen oder Konfigurationen einzurichten. In diesem Fall wird einfach eine Meldung in das Protokoll geschrieben, die anzeigt, dass der EA bereit ist, mit dem Python-Server zu interagieren.

int OnInit()
{
   Print("Expert initialized. Ready to send data to Python.");
   return(INIT_SUCCEEDED);
}

Der Rückgabewert INIT_SUCCEEDED bedeutet, dass die Initialisierung erfolgreich war.

Deinitialisierung (OnDeinit)

Diese Funktion wird ausgelöst, wenn der EA entfernt wird oder die MetaTrader-Plattform geschlossen wird. Sie wird normalerweise für Aufräumarbeiten verwendet, z. B. für die Freigabe von Ressourcen oder das Schließen offener Dateien. In diesem Fall wird einfach eine Meldung ausgegeben, dass der EA deinitialisiert wurde und nicht mehr aktiv ist.

void OnDeinit(const int reason)
{
   Print("Expert deinitialized.");
}

OnTick (Kernfunktion)

Dies ist die Hauptfunktion des EA, die jedes Mal ausgeführt wird, wenn sich die Marktbedingungen ändern (bei jedem neuen Tick).

void OnTick()
{
   // Check if enough time has passed since the last signal update
   if(TimeCurrent() - lastSignalTime < signalInterval)
   {
      return;  // Skip if it's too soon to update
   }

   // Collect data and prepare CSV for Python
   string csvData = "date,prev_high,prev_low,prev_open,prev_close,prev_volume\n";

   // Get the previous trend data for the last `trendDays`
   for(int i = 1; i <= 10; i++)  // You can adjust the trendDays here
   {
      datetime prevDate = iTime(Symbol(), PERIOD_D1, i);
      double prevHigh = iHigh(Symbol(), PERIOD_D1, i);
      double prevLow = iLow(Symbol(), PERIOD_D1, i);
      double prevOpen = iOpen(Symbol(), PERIOD_D1, i);
      double prevClose = iClose(Symbol(), PERIOD_D1, i);
      long prevVolume = iVolume(Symbol(), PERIOD_D1, i);

      csvData += StringFormat("%s,%.5f,%.5f,%.5f,%.5f,%ld\n",
                              TimeToString(prevDate, TIME_DATE | TIME_MINUTES),
                              prevHigh, prevLow, prevOpen, prevClose, prevVolume);
   }

   // Save data to CSV file
   string fileName = StringFormat("%s_analytics.csv", Symbol());
   int fileHandle = FileOpen(fileName, FILE_WRITE | FILE_CSV | FILE_ANSI);
   if(fileHandle != INVALID_HANDLE)
   {
      FileWriteString(fileHandle, csvData);
      FileClose(fileHandle);
      Print("CSV file created: ", fileName);
   }
}

Außerdem führt es die folgenden Vorgänge aus:

• Überprüfung des Signalintervalls: Der EA prüft zunächst mit TimeCurrent(), ob seit der letzten Signalaktualisierung genügend Zeit vergangen ist. Wenn nicht, wird die Verarbeitung übersprungen.
• Datenerhebung: Der EA sammelt Marktdaten für die letzten 10 Tage (oder mehr, wenn Sie den Wert in der Schleife ändern), einschließlich: Höchst-, Tiefst-, Eröffnungs- und Schlusskurs sowie Volumen des Vortages.
• Datenformatierung: Anschließend werden diese Daten in ein CSV-Format formatiert, um sie einfach an den Python-Server zu übertragen. 
• Speichern von CSV-Dateien: Die Daten werden als .csv-Datei mit dem Namen <Symbol>_analytics.csv auf der Festplatte gespeichert. Wenn das Erstellen und Schreiben der Datei erfolgreich war, wird eine Erfolgsmeldung ausgegeben.

HTTP-Anfrage an den Python-Server (WebRequest)

string headers = "Content-Type: application/json\r\n";
char result[];
string resultHeaders;
int responseCode = WebRequest(
    "POST",                  // HTTP method
    pythonUrl,               // URL
    headers,                 // Custom headers
    timeout,                 // Timeout in milliseconds
    data,                    // Data to send
    result,                  // Response content
    resultHeaders            // Response headers
);

if(responseCode == 200)
{
    string response = CharArrayToString(result);
    Print("Received response: ", response);
}
else
{
    Print("Error: HTTP request failed with code ", responseCode);
}

Nach der Aufbereitung der Daten im CSV-Format sendet der EA diese Daten per HTTP POST an einen Python-Server.

• Headers: Die Kopfzeile Content-Type ist auf application/json gesetzt, was dem Server mitteilt, dass die gesendeten Daten im JSON-Format vorliegen.
• WebRequest: Die Funktion WebRequest wird verwendet, um die HTTP-POST-Anfrage an den Python-Server zu senden. Die Funktion liefert:

1) responseCode: Der HTTP-Antwortcode (z. B. 200 für Erfolg).

2) result: Der Inhalt der Antwort des Servers (in der Regel die Analyseergebnisse).

Abb. 2. WebRequest Ablaufdiagramm

• Ist die Anfrage erfolgreich (responseCode == 200), wird der Inhalt der Antwort von einem char-Array in einen String konvertiert und eine Erfolgsmeldung ausgegeben. Wenn die Anfrage fehlschlägt, wird eine Fehlermeldung angezeigt.

Parsing und Anzeige der Antwort:

if(responseCode == 200)
{
    string signal = "";
    string avgPrice = "";
    string avgVolume = "";
    string explanation = "";

    // Extract signal, avgPrice, avgVolume, and explanation from the response
    int signalStart = StringFind(response, "\"signal\":");
    int signalEnd = StringFind(response, "\"average_price\":");
    int explanationStart = StringFind(response, "\"signal_explanation\":");
    int avgPriceStart = StringFind(response, "\"average_price\":");
    int avgVolumeStart = StringFind(response, "\"average_volume\":");

    if(signalStart != -1 && signalEnd != -1)
    {
        signal = StringSubstr(response, signalStart + 10, signalEnd - signalStart - 12);
    }

    if(explanationStart != -1)
    {
        explanation = StringSubstr(response, explanationStart + 23, StringFind(response, "\"", explanationStart + 23) - (explanationStart + 23));
    }

    if(avgPriceStart != -1)
    {
        avgPrice = StringSubstr(response, avgPriceStart + 16, StringFind(response, "\"", avgPriceStart + 16) - (avgPriceStart + 16));
    }

    if(avgVolumeStart != -1)
    {
        avgVolume = StringSubstr(response, avgVolumeStart + 18, StringFind(response, "\"", avgVolumeStart + 18) - (avgVolumeStart + 18));
    }

    // Update the chart if the signal has changed
    if(signal != lastSignal)
    {
        lastSignal = signal;
        lastSignalTime = TimeCurrent();  // Update last signal time
        string receivedSummary = "Signal: " + signal + "\n" +
                                 "Avg Price: " + avgPrice + "\n" +
                                 "Avg Volume: " + avgVolume + "\n" +
                                 "Explanation: " + explanation;
        Print("Received metrics and signal: ", receivedSummary);
        Comment(receivedSummary);  // Display it on the chart
    }
}

 Nach Erhalt der Antwort vom Python-Server analysiert der EA die Antwort, um Schlüsseldaten zu extrahieren, z. B.:

• Signal: Das Handelssignal (z.B. „kaufen“ oder „verkaufen“).
• Avg Price: Der aus der Analyse abgeleitete Durchschnittspreis.
• Avg Volume: Das durchschnittliche Volumen des Handels.
• Explanation: Eine Erklärung, warum das Signal erzeugt wurde.

Die Funktion verwendet StringFind und StringSubstr, um diese Werte aus der Antwortzeichenfolge zu extrahieren.

Wenn sich das Signal seit der letzten Aktualisierung geändert hat (signal != lastSignal), werden:

1) die Variablen lastSignal und lastSignalTime aktualisiert und

2) das neue Signal, den Durchschnittspreis, das Volumen und die Erklärung als Kommentar im Chart mit der Funktion Comment() angezeigt.

Signalaktualisierung und Darstellung

Dieser Teil ist in den vorherigen Schritt integriert, in dem das Signal aktualisiert und auf dem Chart angezeigt wird.

if(signal != lastSignal)
{
    lastSignal = signal;
    lastSignalTime = TimeCurrent();  // Update last signal time
    string receivedSummary = "Signal: " + signal + "\n" +
                             "Avg Price: " + avgPrice + "\n" +
                             "Avg Volume: " + avgVolume + "\n" +
                             "Explanation: " + explanation;
    Print("Received metrics and signal: ", receivedSummary);
    Comment(receivedSummary);  // Display it on the chart
}

 Wenn sich das Signal geändert hat (d.h. es unterscheidet sich von dem vorherigen), dann:

• aktualisiert der EA die Variablen lastSignalund lastSignalTime,
• erstellt eine Zusammenfassung als Zeichenkette, die das Signal, den Durchschnittspreis, das Durchschnittsvolumen und eine Erklärung enthält und
• zeigt die Zusammenfassung im Chart als Kommentar an und druckt sie in das Protokoll.

CharArrayToString (Hilfsfunktion)

string CharArrayToString(char &arr[])
{
    string result = "";
    for(int i = 0; i < ArraySize(arr); i++)
    {
        result += StringFormat("%c", arr[i]);
    }
    return(result);
}

Diese Hilfsfunktion wird verwendet, um ein (aus der HTTP-Antwort erhaltenes) char-Array in eine Zeichenkette zu konvertieren. Er durchläuft jedes Element des char-Arrays und fügt das entsprechende Zeichen an die Ergebniszeichenkette an.

Jeder dieser Schritte ist für einen bestimmten Teil des Prozesses vorgesehen: Sammeln von Daten, Senden der Daten an den Python-Server, Empfangen der Analyse und Aktualisieren des Charts mit dem Handelssignal. Der Ansatz stellt sicher, dass der EA autonom agieren, relevante Marktdaten sammeln und Entscheidungen auf der Grundlage von Python-basierten Analysen treffen kann.

Ergebnisse

Der erste Schritt besteht darin, sicherzustellen, dass Ihr Python-Skript läuft und den gewünschten Server aktiv abhört. Ausführliche Anweisungen zum Einrichten und Ausführen des Skripts finden Sie im obigen Abschnitt über Python. Wenn es aktiv abhört, sollte es schreiben: 

Running on http://189.7.6.8:5877

Bitte beachten Sie, dass die oben erwähnte API und der Host nicht die tatsächlich verwendeten sind, sondern zu Lehrzwecken erstellt wurden. Als Nächstes starten wir den MQL5 EA. Wenn die Verbindung zwischen MQL5 und dem Python-Server erfolgreich hergestellt wurde, sehen Sie auf der Registerkarte „Experten“ des Charts Protokollierungsmeldungen. Außerdem zeigt das Python-Skript, das in der Eingabeaufforderung läuft, die empfangenen Metriken an.

In der Eingabeaufforderung wird Folgendes angezeigt:

189.7.6.8 - - [21/Jan/2025 10:53:44] "POST /analyze HTTP/1.1" 200 -
Received metrics:
                date  prev_high  prev_low  prev_open  prev_close  prev_volume
0   2025.01.20 00:00    868.761   811.734    826.389     863.078      83086.0
1   2025.01.19 00:00    856.104   763.531    785.527     826.394      82805.0
2   2025.01.18 00:00    807.400   752.820    795.523     785.531      82942.0
3   2025.01.17 00:00    886.055   790.732    868.390     795.546      83004.0
4   2025.01.16 00:00    941.334   864.202    932.870     868.393      83326.0
5   2025.01.15 00:00    943.354   870.546    890.620     932.876      83447.0
6   2025.01.14 00:00    902.248   848.496    875.473     890.622      83164.0
7   2025.01.13 00:00    941.634   838.520    932.868     875.473      82516.0
8   2025.01.12 00:00    951.350   868.223    896.455     932.883      83377.0
9   2025.01.11 00:00    920.043   857.814    879.103     896.466      83287.0
10               NaN        NaN       NaN        NaN         NaN          NaN

Die oben genannten Informationen werden von Pandas zur Analyse und Signalerzeugung verwendet. Die Daten des zehnten Tages zeigen „NaN“ an, da der Tag noch nicht abgeschlossen ist, d. h. die Analyse stützt sich hauptsächlich auf die Werte der vorangegangenen Tage. Er berücksichtigt jedoch auch die aktuellen Kursstände des zehnten Tages, die unvollständig sind. Im Folgenden finden Sie die Protokollierungs- und Analyseergebnisse, die von Pandas in der Eingabeaufforderung (CMD) angezeigt werden.

Average Price: 865.884525
Average Volume: 83095.4
Generated Signal: SELL
Signal Explanation: The last close price (nan) is lower than the average price (865.884525).

Auf dem MetaTrader 5 wird Folgendes angezeigt:

Beginnen wir mit der Überprüfung der Protokollierung auf der Registerkarte „Experten“. Nachfolgend finden Sie die erzielten Ergebnisse.

2025.01.21 10:50:28.106 External Flow (Boom 300 Index,D1)       CSV file created: Boom 300 Index_analytics.csv
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)       Received response: {
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "average_price": 865.884525,
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "average_volume": 83095.4,
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "signal": "SELL",
2025.01.21 10:50:28.161 External Flow (Boom 300 Index,D1)         "signal_explanation": "The last close price (nan) is lower than the average price (865.884525)."

Das Ergebnis wird ebenfalls im Chart angezeigt, und der Vorgang wird entsprechend den in den Eingabeparametern angegebenen Zeitüberschreitungseinstellungen wiederholt.

Abb. 3. Angezeigtes Ergebnis

Nachfolgend sehen Sie das Chart eines profitablen Handels, den ich auf der Grundlage des generierten Signals und zusätzlicher Analysen platziert habe. Der Handel wird zur besseren Übersichtlichkeit auf dem M1-Zeitrahmen (1 Minute) angezeigt.

Abb. 4. Platzierter Handel

Schlussfolgerung

Nachdem ich die Schritte zur Implementierung fortgeschrittener Analysen unter Verwendung externer Bibliotheken wie Pandas für dieses Projekt skizziert habe, glaube ich, dass wir eine solide Grundlage für die Entwicklung fortgeschrittener Tools für Preisaktionen und Marktanalysen geschaffen haben. Ich ermutige jeden Händler, dies als einen allgemeinen Leitfaden zum Verständnis der zu erwartenden Marktbewegungen zu betrachten. Für eine optimale Handelsausführung sollten Sie jedoch auch andere Strategien einsetzen, mit denen Sie vertraut sind. Ihr Feedback und Ihre Kommentare sind uns sehr willkommen, da wir weiterhin an der Entwicklung professioneller Tools für erweiterte Marktanalysen arbeiten.

Datum	Name des Werkzeugs	Beschreibung	Version	Aktualisierungen	Hinweis
01/10/24	Chart Projector	Skript zur Überlagerung der Kursentwicklung des Vortages mit Geistereffekt.	1.0	Erste Veröffentlichung	Erstes Werkzeug in Lynnchris Tool Chest
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Zweites Werkzeug in Lynnchris Tool Chest
27/11/24	Analytics Master	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden.	1.01	Zweite Veröffentlichung	Drittes Werkzeug in Lynnchris Tool Chest
02/12/24	Analytics Forecaster	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration.	1.1	Dritte Auflage	Werkzeug Nummer 4
09/12/24	Volatilitäts-Navigator	Der EA analysiert die Marktbedingungen anhand der Indikatoren Bollinger Bands, RSI und ATR.	1.0	Erste Veröffentlichung	Werkzeug Nummer 5
19/12/24	Mean Reversion Signal Reaper	Analysiert den Markt anhand der Strategie „Umkehr zur Mitte“ und liefert Signale.	1.0	Erste Veröffentlichung	Werkzeug Nummer 6
9/01/2025	Signal-Impuls	Analysator für mehrere Zeitrahmen.	1.0	Erste Veröffentlichung	Werkzeug Nummer 7
17/01/2025	Metrics Board	Bedienfeld mit Taste für die Analyse.	1.0	Erste Veröffentlichung	Werkzeug Nummer 8
21/01/2025	External Flow	Analytik durch externe Bibliotheken.	1.0	Erste Veröffentlichung	Werkzeug Nummer 9