Ir para o conteúdo

Como criar um robô de negociação em Python

Este artigo e vídeo oferecem instruções passo a passo para criar um robô de negociação em Python.

Nota

O cTrader é a única plataforma de negociação importante com suporte nativo para Python, permitindo-lhe escrever código em Python e criar bots, indicadores técnicos e ferramentas diretamente no cTrader Windows ou Mac. Não é necessário qualquer adaptador ou solução complexa.

Criar um robô de negociação

No separador cBots da aplicação Algo, clique no botão Novo para começar a criar um novo robô de negociação.

Atribua um nome ao cBot e selecione Python como linguagem de programação.

Nota

O cTrader fornece vários algoritmos pré-criados em Python que abrangem uma vasta gama de estratégias e ações de negociação automatizada. Estes modelos de algoritmos já contêm lógica de negociação e parâmetros personalizáveis e estão prontos a ser executados assim que os guardar e construir.

Selecione Utilizar modelo como método de criação, escolha Grid Sample e, em seguida, clique em Criar.

O Grid cBot implementa uma estratégia de negociação em grelha em que são colocadas várias ordens de compra ou venda para um símbolo em intervalos ou passos de preço regulares, resultando numa grelha de posições.

Vamos construir o nosso cBot para validar o seu código.

Prima Ctrl+B ou clique em Construir.

Prima Cmd+B ou clique no ícone Construir.

Adicionar um indicador

Vamos incorporar um indicador no nosso robô de negociação para melhorar a sua precisão.

O Relative Strength Index (RSI) é um indicador popular que sinaliza condições de sobrecompra ou sobrevenda no mercado. Este indicador pode ajudar o nosso cBot a evitar a abertura de novas posições quando o mercado está esticado numa direção.

Integre o RSI na lógica do robô. Inicialize o indicador com um período predefinido de 14 e defina os níveis de sobrecompra e sobrevenda para 70 e 30, respetivamente. Utilize os preços de fecho do símbolo para criar o 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)

Adicione a lógica para verificar se as condições do RSI permitem uma negociação antes de abrir uma posição. Se o filtro bloquear a negociação, registe uma mensagem que mostre o valor atual do 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()))

Escreva o código que garante que a posição da grelha é aberta apenas se o preço tiver variado o suficiente e o valor do RSI estiver dentro de um intervalo neutro. Utilize o valor do RSI da última barra fechada para obter estabilidade e imprima uma mensagem quando for bloqueado pelo filtro 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)

Ajuste a lógica de cálculo da distância em pips entre o preço de mercado atual e o preço de entrada de uma posição.

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

Pode copiar o código Python completo com o indicador RSI integrado abaixo:

 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

Iniciar uma instância

Vamos voltar ao nosso cBot e construí-lo. Agora, clique no ícone Iniciar cBot para qualquer instância e o robô de negociação começará a funcionar.

Em alternativa, pode clicar em Adicionar instância, especificar os parâmetros de instância preferidos, adicionar a nova instância e iniciá-la.

Ao adicionar e personalizar novas instâncias, pode executar o cBot simultaneamente em diferentes símbolos, períodos ou parâmetros.

Executar o bot noutro local

Com a sincronização na nuvem ativada, o cBot aparece automaticamente em todas as aplicações cTrader onde o seu cTID está ativo. Podemos iniciar o mesmo robô de negociação na Nuvem em qualquer aplicação cTrader, incluindo o cTrader Mobile e Web.

No cTrader Algo, inicie o cBot.

Este artigo demonstrou como criar um robô de negociação em Python e iniciá-lo, permitindo-lhe automatizar as suas estratégias e executar algoritmos em qualquer dispositivo.

Image title