Ir para o conteúdo

Parâmetros personalizáveis em algoritmos Python

Ao desenvolver bots de negociação em Python, indicadores técnicos ou plugins, pode ser necessário adicionar e configurar parâmetros personalizáveis. Este artigo explica como declarar e utilizar parâmetros personalizáveis num algoritmo Python para o cTrader.

Nota

O modelo de execução para algoritmos Python do cTrader envolve um motor .NET/C#, que requer que todos os parâmetros personalizáveis sejam declarados dentro de ficheiros .cs. Sempre que cria um algoritmo Python no cTrader, um ficheiro .cs para esse algoritmo é gerado automaticamente e armazenado na pasta relevante.

Localização

A localização do ficheiro .cs para um algoritmo Python depende do tipo de algoritmo, seja ele um cBot, indicador ou plugin, bem como do nome do algoritmo.

  • Para cBots: Documents/cAlgo/Sources/Robots/{cBot-name}/{cBot-name}/
  • Para indicadores: Documents/cAlgo/Sources/Indicators/{Indicator-name}/{Indicator-name}/
  • Para plugins: Documents/cAlgo/Sources/Indicators/{Plugin-name}/{Plugin-name}/

Pode seguir estas instruções para localizar o ficheiro .cs para um algoritmo Python:

  1. Clique com o botão direito do rato no algoritmo no cTrader Windows ou Mac, depois selecione Mostrar na pasta.

  2. Navegue através de {nome-do-algoritmo}/{nome-do-algoritmo}, depois identifique o ficheiro .cs (ficheiro fonte C#) na lista de ficheiros.

O ficheiro .cs geralmente tem o mesmo nome que o algoritmo, com todos os espaços removidos. Por exemplo, um algoritmo chamado Amazing Aroon cBot resulta num ficheiro AmazingArooncBot.cs.

Dica

Na mesma pasta, pode aceder ao código Python principal do seu algoritmo, armazenado num ficheiro .py como Amazing Aroon cBot_main.py. O ficheiro Python segue uma convenção de nomenclatura simples:

  • Para cBots: nome-do-cBot_main.py
  • Para indicadores: nome-do-Indicador_main.py
  • Para plugins: nome-do-Plugin_main.py

Conteúdo

Abra o ficheiro .cs em qualquer editor de texto ou código, como o NotePad ou o Visual Studio Code, e deverá ver um código semelhante a este:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using cAlgo.API;

namespace cAlgo.Robots;

[Robot(AccessRights = AccessRights.None, AddIndicators = true)]
public partial class AmazingArooncBot : Robot
{
    [Parameter("Volume (Lots)", DefaultValue = 0.01)]
    public double VolumeInLots { get; set; }

    [Parameter("Stop Loss (Pips)", DefaultValue = 10, MaxValue = 100, MinValue = 1, Step = 1)]
    public double StopLossInPips { get; set; }

    [Parameter("Take Profit (Pips)", DefaultValue = 10, MaxValue = 100, MinValue = 1, Step = 1)]
    public double TakeProfitInPips { get; set; }

    [Parameter("Label", DefaultValue = "AmazingArooncBot")]
    public string Label { get; set; }

    [Parameter("Periods", DefaultValue = 25, Group = "Aroon", MinValue = 2)]
    public int Periods { get; set; }
}

Nota

Verá uma classe vazia se criou o seu cBot Python do zero sem usar um modelo.

Qualquer parâmetro declarado no ficheiro .cs pode ser usado no ficheiro Python principal, que contém o código exibido no editor de código. O código Python principal abaixo ilustra o uso dos parâmetros personalizáveis:

 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
import clr

clr.AddReference("cAlgo.API")

# Import cAlgo API types
from cAlgo.API import *

# Import trading wrapper functions
from robot_wrapper import *

class AmazingArooncBot():
    def on_start(self):
        self.volumeInUnits = api.Symbol.QuantityToVolumeInUnits(api.VolumeInLots)
        self.aroon = api.Indicators.Aroon(api.Periods)

    def on_bar_closed(self):
        if self.aroon.Up.Last(0) > self.aroon.Down.Last(0) and self.aroon.Up.Last(1) < self.aroon.Down.Last(1):
            self.close_positions(TradeType.Sell)
            api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)
        elif self.aroon.Up.Last(0) < self.aroon.Down.Last(0) and self.aroon.Up.Last(1) > self.aroon.Down.Last(1):
            self.close_positions(TradeType.Buy)
            api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, self.volumeInUnits, api.Label, api.StopLossInPips, api.TakeProfitInPips)

    def get_bot_positions(self):
        return api.Positions.FindAll(api.Label)

    def close_positions(self, tradeType):
        for position in self.get_bot_positions():
            if position.TradeType != tradeType:
                continue
            api.ClosePosition(position)

Vantagens

A principal vantagem dos parâmetros personalizáveis é que eles aparecem como campos editáveis na interface de utilizador de todas as aplicações cTrader, incluindo cTrader Windows, Mac, Web e Mobile. Os valores nestes campos podem ser facilmente modificados para se adequarem a qualquer necessidade ou operação, sem a necessidade de aceder ou modificar o código fonte do algoritmo.

Na Store do cTrader, os vendedores frequentemente usam parâmetros personalizáveis para garantir que os compradores de algoritmos possam ajustar os algos para se adequarem aos seus objetivos e fluxos de trabalho.

Image title