Saltar a contenido

Parámetros personalizables en algoritmos Python

Al desarrollar bots de operaciones en Python, indicadores técnicos o plugins, es posible que necesite agregar y configurar parámetros personalizables. Este artículo explica cómo declarar y usar parámetros personalizables en un algoritmo Python para cTrader.

Nota

El modelo de ejecución para algoritmos Python de cTrader involucra un motor .NET/C#, que requiere que todos los parámetros personalizables se declaren dentro de archivos .cs. Cada vez que crea un algoritmo Python en cTrader, se genera automáticamente un archivo .cs para ese algoritmo y se almacena en la carpeta correspondiente.

Ubicación

La ubicación del archivo .cs para un algoritmo Python depende del tipo de algoritmo, ya sea un cBot, indicador o plugin, así como del nombre del algoritmo.

  • Para cBots: Documents/cAlgo/Sources/Robots/{nombre-del-cBot}/{nombre-del-cBot}/
  • Para indicadores: Documents/cAlgo/Sources/Indicators/{nombre-del-indicador}/{nombre-del-indicador}/
  • Para plugins: Documents/cAlgo/Sources/Indicators/{nombre-del-plugin}/{nombre-del-plugin}/

Puede seguir estas instrucciones para localizar el archivo .cs de un algoritmo Python:

  1. Haga clic derecho en el algoritmo en cTrader Windows o Mac, luego seleccione Mostrar en carpeta.

  2. Navegue a través de {nombre-del-algoritmo}/{nombre-del-algoritmo}, luego identifique el archivo .cs (archivo fuente C#) de la lista de archivos.

El archivo .cs generalmente tiene el mismo nombre que el algoritmo, con todos los espacios eliminados. Por ejemplo, un algoritmo llamado Amazing Aroon cBot resulta en un archivo AmazingArooncBot.cs.

Consejo

En la misma carpeta, puede acceder al código Python principal de su algoritmo, almacenado en un archivo .py como Amazing Aroon cBot_main.py. El archivo Python sigue una convención de nomenclatura simple:

  • Para cBots: nombre-del-cBot_main.py
  • Para indicadores: nombre-del-indicador_main.py
  • Para plugins: nombre-del-plugin_main.py

Contenido

Abra el archivo .cs en cualquier editor de texto o código, como NotePad o Visual Studio Code, y debería ver un código similar 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á una clase vacía si creó su cBot Python desde cero sin usar una plantilla.

Cualquier parámetro declarado en el archivo .cs puede utilizarse en el archivo Python principal, que contiene el código mostrado en el editor de código. El código Python principal a continuación ilustra el uso de los parámetros personalizables:

 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)

Ventajas

La principal ventaja de los parámetros personalizables es que aparecen como campos editables en la interfaz de usuario de todas las aplicaciones de cTrader, incluyendo cTrader Windows, Mac, Web y Mobile. Los valores en estos campos pueden modificarse fácilmente para adaptarse a cualquier necesidad u operación, sin necesidad de acceder o modificar el código fuente del algoritmo.

En la Store, los vendedores a menudo utilizan parámetros personalizables para asegurarse de que los compradores de algoritmos puedan ajustar los algoritmos para que se adapten a sus objetivos y flujos de trabajo.

Image title