Zum Inhalt

Wie man einen Handelsroboter in Python erstellt

Dieser Artikel und das Video bieten Schritt-für-Schritt-Anleitungen zum Erstellen eines Handelsroboters in Python.

Hinweis

cTrader ist die einzige große Handelsplattform mit nativer Python-Unterstützung, die es Ihnen ermöglicht, Code in Python zu schreiben und Bots, technische Indikatoren und Tools direkt in cTrader Windows oder Mac zu erstellen. Kein Adapter oder komplexe Problemumgehung erforderlich.

Einen Handelsroboter erstellen

Klicken Sie in der Registerkarte cBots der Algo-App auf die Schaltfläche Neu, um mit der Erstellung eines neuen Handelsroboters zu beginnen.

Geben Sie dem cBot einen Namen und wählen Sie Python als Programmiersprache.

Hinweis

cTrader bietet mehrere vorgefertigte Algorithmen in Python, die eine breite Palette von Strategien und automatisierten Handelsaktionen abdecken. Diese Algorithmusvorlagen enthalten bereits Handelslogik und anpassbare Parameter und sind bereit zur Ausführung, sobald Sie sie speichern und erstellen.

Wählen Sie Vorlage verwenden als Erstellungsmethode, wählen Sie Grid Sample und klicken Sie dann auf Erstellen.

Der Grid cBot implementiert eine Grid-Handelsstrategie, bei der mehrere Kauf- oder Verkaufsorders für ein Symbol in regelmäßigen Kursintervallen oder Schritten platziert werden, was zu einem Raster von Positionen führt.

Lassen Sie uns unseren cBot erstellen, um seinen Code zu validieren.

Drücken Sie Ctrl+B oder klicken Sie auf Erstellen.

Drücken Sie Cmd+B oder klicken Sie auf das Symbol Erstellen.

Indikator hinzufügen

Lassen Sie uns einen Indikator in unseren Handelsroboter integrieren, um seine Genauigkeit zu verbessern.

Der Relative Strength Index (RSI) ist ein beliebter Indikator, der überkaufte oder überverkaufte Bedingungen im Markt signalisiert. Dieser Indikator kann unserem cBot helfen, das Eröffnen neuer Positionen zu vermeiden, wenn der Markt in eine Richtung überdehnt ist.

Integrieren Sie RSI in die Roboterlogik. Initialisieren Sie den Indikator mit einer Standardperiode von 14 und setzen Sie die überkauften und überverkauften Niveaus auf 70 bzw. 30. Verwenden Sie die Schlusskurse des Symbols, um den RSI zu erstellen.

1
2
3
4
self.rsi_period = getattr(api, "RsiPeriod", 14)
self.rsi_overbought = getattr(api, "RsiOverbought", 70)
self.rsi_oversold = getattr(api, "RsiOversold", 30)
self.rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, self.rsi_period)

Fügen Sie die Logik hinzu, um zu überprüfen, ob die RSI-Bedingungen einen Handel zulassen, bevor eine Position eröffnet wird. Wenn der Filter den Handel blockiert, protokollieren Sie eine Nachricht, die den aktuellen RSI-Wert anzeigt.

1
2
3
4
5
6
if len(self.get_grid_positions()) == 0:
    # self.open_position()
    if self.passes_rsi_filter():
        self.open_position()
    else:
        api.Print("RSI filter blocked initial entry (RSI={:.2f})".format(self.get_rsi_value()))

Schreiben Sie den Code, der sicherstellt, dass die Grid-Position nur geöffnet wird, wenn sich der Kurs ausreichend bewegt hat und der RSI-Wert innerhalb eines neutralen Bereichs liegt. Verwenden Sie den RSI-Wert des letzten geschlossenen Balkens für Stabilität und geben Sie eine Nachricht aus, wenn er vom RSI-Filter blockiert wird.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
if distance >= api.StepPips:
    # self.open_position()
    if self.passes_rsi_filter():
        self.open_position()
    else:
        api.Print("RSI filter: no new entry (RSI={:.2f}, range {}-{})"
                    .format(self.get_rsi_value(), self.rsi_oversold, self.rsi_overbought))

def get_rsi_value(self):
    # Use the last CLOSED bar for stability
    return self.rsi.Result.Last(1)

def passes_rsi_filter(self):
    r = self.get_rsi_value()
    return (r > self.rsi_oversold) and (r < self.rsi_overbought)

Passen Sie die Berechnungslogik für den Abstand in Pips zwischen dem aktuellen Marktkurs und dem Einstiegskurs einer Position an.

1
2
3
4
5
6
7
def get_distance_in_pips(self, position):
    # return (position.EntryPrice - api.Symbol.Ask if position.TradeType == TradeType.Buy else api.Symbol.Bid - position.EntryPrice) / api.Symbol.PipSize
    if position.TradeType == TradeType.Buy:
        diff = position.EntryPrice - api.Symbol.Ask
    else:
        diff = api.Symbol.Bid - position.EntryPrice
    return diff / api.Symbol.PipSize

Sie können den vollständigen Python-Code mit dem integrierten RSI-Indikator unten kopieren:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class SupercBot():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.enoughMoney = True

        self.rsi_period = getattr(api, "RsiPeriod", 14)
        self.rsi_overbought = getattr(api, "RsiOverbought", 70)
        self.rsi_oversold = getattr(api, "RsiOversold", 30)
        self.rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, self.rsi_period)

        if len(self.get_grid_positions()) == 0:
            if self.passes_rsi_filter():
                self.open_position()
            else:
                api.Print("RSI filter blocked initial entry (RSI={:.2f})".format(self.get_rsi_value()))

    def on_tick(self):
        grid_positions = self.get_grid_positions()
        net_profit_sum = sum([p.NetProfit for p in grid_positions])
        if net_profit_sum >= api.TargetProfit:
            api.Print("Target profit is reached. Closing all grid positions")
            self.close_grid_positions()
            api.Print("All grid positions are closed. Stopping cBot")
            api.Stop()

        if len(grid_positions) > 0 and self.enoughMoney == True:
            position_with_highest_pips = sorted(grid_positions, key=lambda pos: pos.Pips, reverse=True)[0]
            distance = self.get_distance_in_pips(position_with_highest_pips)          
            if distance >= api.StepPips:
                if self.passes_rsi_filter():
                    self.open_position()
                else:
                    api.Print("RSI filter: no new entry (RSI={:.2f}, range {}-{})"
                              .format(self.get_rsi_value(), self.rsi_oversold, self.rsi_overbought))

    def get_rsi_value(self):
        # Use the last CLOSED bar for stability
        return self.rsi.Result.Last(1)

    def passes_rsi_filter(self):
        r = self.get_rsi_value()
        return (r > self.rsi_oversold) and (r < self.rsi_overbought)

    def get_grid_positions(self):
        return [pos for pos in api.Positions if pos.SymbolName == api.SymbolName and pos.TradeType == api.TradeType]

    def open_position(self):
        result = api.ExecuteMarketOrder(api.TradeType, api.SymbolName, self.volumeInUnits, "Grid")
        if result.Error == ErrorCode.NoMoney:
            self.enoughMoney = False
            api.Print("Not enough money to open additional positions")

    def close_grid_positions(self):
        for position in self.get_grid_positions():
            position.Close()

        if len(self.get_grid_positions()) > 0:
            self.close_grid_positions()

    def get_distance_in_pips(self, position):
        if position.TradeType == TradeType.Buy:
            diff = position.EntryPrice - api.Symbol.Ask
        else:
            diff = api.Symbol.Bid - position.EntryPrice
        return diff / api.Symbol.PipSize

Instanz starten

Kehren wir zu unserem cBot zurück und erstellen ihn. Klicken Sie nun auf das Symbol cBot starten für eine beliebige Instanz, und der Handelsroboter beginnt zu laufen.

Alternativ können Sie auf Instanz hinzufügen klicken, Ihre bevorzugten Instanzparameter angeben, die neue Instanz hinzufügen und sie starten.

Durch Hinzufügen und Anpassen neuer Instanzen können Sie den cBot gleichzeitig auf verschiedenen Symbolen, Perioden oder Parametern ausführen.

Bot anderswo ausführen

Mit aktivierter Cloud-Synchronisierung erscheint der cBot automatisch in allen cTrader-Anwendungen, in denen Ihre cTID aktiv ist. Wir können denselben Handelsroboter in der Cloud in jeder cTrader-App starten, einschließlich cTrader Mobile und Web.

Starten Sie in cTrader Algo den cBot.

Dieser Artikel hat gezeigt, wie man einen Python-Handelsroboter erstellt und startet, und ermöglicht es Ihnen, Ihre Strategien zu automatisieren und Algos auf jedem Gerät auszuführen.

Image title