Aller au contenu

Comment créer un robot de trading en Python

Cet article et cette vidéo offrent des instructions étape par étape pour créer un robot de trading en Python.

Remarque

cTrader est la seule plateforme de trading majeure avec une prise en charge native de Python, vous permettant d'écrire du code en Python et de créer des bots, des indicateurs techniques et des outils directement dans cTrader Windows ou Mac. Aucun adaptateur ou solution de contournement complexe n'est nécessaire.

Créer un robot de trading

Dans l'onglet cBots de l'application Algo, cliquez sur le bouton Nouveau pour commencer à créer un nouveau robot de trading.

Donnez un nom au cBot et sélectionnez Python comme langage de programmation.

Remarque

cTrader fournit plusieurs algorithmes prédéfinis en Python couvrant un large éventail de stratégies et d'actions de trading automatisées. Ces modèles d'algorithmes contiennent déjà une logique de trading et des paramètres personnalisables et sont prêts à être exécutés une fois que vous les avez enregistrés et compilés.

Sélectionnez À l'aide d'un modèle comme méthode de création, choisissez Grid Sample, puis cliquez sur Créer.

Le Grid cBot met en œuvre une stratégie de trading en grille où plusieurs ordres d'achat ou de vente pour un symbole sont placés à intervalles de prix réguliers ou par étapes, ce qui donne une grille de positions.

Créons notre cBot pour valider son code.

Appuyez sur Ctrl+B ou cliquez sur Compiler.

Appuyez sur Cmd+B ou cliquez sur l'icône Compiler.

Ajouter un indicateur

Intégrons un indicateur dans notre robot de trading pour améliorer sa précision.

Le Relative Strength Index (RSI) est un indicateur populaire qui signale des conditions de surachat ou de survente sur le marché. Cet indicateur peut aider notre cBot à éviter d'ouvrir de nouvelles positions lorsque le marché est étiré dans une direction.

Intégrez le RSI dans la logique du robot. Initialisez l'indicateur avec une période par défaut de 14 et définissez les niveaux de surachat et de survente à 70 et 30 respectivement. Utilisez les cours de clôture du symbole pour créer le RSI.

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)

Ajoutez la logique pour vérifier si les conditions du RSI permettent un trade avant d'ouvrir une position. Si le filtre bloque le trade, enregistrez un message indiquant la valeur actuelle du RSI.

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()))

Écrivez le code qui garantit que la position en grille n'est ouverte que si le cours s'est suffisamment déplacé et que la valeur du RSI se situe dans une plage neutre. Utilisez la valeur du RSI de la dernière barre clôturée pour plus de stabilité et affichez un message lorsqu'elle est bloquée par le filtre RSI.

 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)

Ajustez la logique de calcul de la distance en pips entre le cours actuel du marché et le cours d'entrée d'une position.

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

Vous pouvez copier le code Python complet avec l'indicateur RSI intégré ci-dessous :

 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

Démarrer une instance

Revenons à notre cBot et compilons-le. Maintenant, cliquez sur l'icône Démarrer cBot pour n'importe quelle instance, et le robot de trading commencera à fonctionner.

Vous pouvez également cliquer sur Ajouter une instance, spécifier les paramètres d'instance de votre choix, ajouter la nouvelle instance et la démarrer.

En ajoutant et en personnalisant de nouvelles instances, vous pouvez exécuter le cBot simultanément sur différents symboles, périodes ou paramètres.

Exécuter le bot ailleurs

Avec la synchronisation du cloud activée, le cBot apparaît automatiquement dans toutes les applications cTrader où votre cTID est actif. Nous pouvons démarrer le même robot de trading dans le cloud dans n'importe quelle application cTrader, y compris cTrader Mobile et Web.

Dans cTrader Algo, démarrez le cBot.

Cet article a démontré comment créer un robot de trading Python et le démarrer, vous permettant d'automatiser vos stratégies et d'exécuter des algorithmes sur n'importe quel appareil.

Image title