La mano a la mano te enseña cómo cambiar la política de una sola variedad en Python a una política de varias variedades.

Primero, te enseño a cambiar la política de una sola variedad de Python a una política de varias variedades.

En el último artículo, implementamos una estrategia muy simple en Python:"Estrategia de persecución y caída en Python"La estrategia es muy sencilla, es decir, la búsqueda de la caída y la caída. A veces queremos usar la misma lógica de negociación para operar diferentes pares de operaciones. Se pueden crear varios robots y configurar diferentes pares de operaciones para realizar operaciones en diferentes monedas. Si la estrategia no es muy compleja, dada la gran flexibilidad de la plataforma de negociación cuantificada por los inventores.

El código fuente de la estrategia después de la modificación:

'''backtest
start: 2019-02-20 00:00:00
end: 2020-01-10 00:00:00
period: 1m
exchanges: [{"eid":"OKEX","currency":"BTC_USDT"},{"eid":"OKEX","currency":"ETH_USDT","stocks":30},{"eid":"OKEX","currency":"LTC_USDT","stocks":100}]
'''

import time
import json

params = {
    "arrBasePrice": [-1, -1, -1],     # -1
    "arrRatio": [0.05, 0.05, 0.05],         # 0.05
    "arrAcc": [],           # _C(exchange.GetAccount)
    "arrLastCancelAll": [0, 0, 0], # 0
    "arrMinStocks": [0.01, 0.01, 0.01],     # 0.01
    "arrPricePrecision": [2, 2, 2], # 2
    "arrAmountPrecision": [3, 2, 2], # 2
    "arrTick":[]
}

def CancelAll(e):
    while True : 
        orders = _C(e.GetOrders)
        for i in range(len(orders)) :
            e.CancelOrder(orders[i]["Id"], orders[i])
        if len(orders) == 0 :
            break
        Sleep(1000)

def process(e, index):
    global params
    ticker = _C(e.GetTicker)
    params["arrTick"][index] = ticker
    if params["arrBasePrice"][index] == -1 :
        params["arrBasePrice"][index] = ticker.Last
    if ticker.Last - params["arrBasePrice"][index] > 0 and (ticker.Last - params["arrBasePrice"][index]) / params["arrBasePrice"][index] > params["arrRatio"][index]:
        params["arrAcc"][index] = _C(e.GetAccount)
        if params["arrAcc"][index].Balance * params["arrRatio"][index] / ticker.Last > params["arrMinStocks"][index]:
            e.Buy(ticker.Last, params["arrAcc"][index].Balance * params["arrRatio"][index] / ticker.Last)
            params["arrBasePrice"][index] = ticker.Last
    if ticker.Last - params["arrBasePrice"][index] < 0 and (params["arrBasePrice"][index] - ticker.Last) / params["arrBasePrice"][index] > params["arrRatio"][index]: 
        params["arrAcc"][index] = _C(e.GetAccount)
        if params["arrAcc"][index].Stocks * params["arrRatio"][index] > params["arrMinStocks"][index]:
            e.Sell(ticker.Last, params["arrAcc"][index].Stocks * params["arrRatio"][index])
            params["arrBasePrice"][index] = ticker.Last
    ts = time.time()
    if ts - params["arrLastCancelAll"][index] > 60 * 5 :
        CancelAll(e)
        params["arrLastCancelAll"][index] = ts 

def main():
    global params
    
    for i in range(len(exchanges)) :    
        params["arrAcc"].append(_C(exchanges[i].GetAccount))
        params["arrTick"].append(_C(exchanges[i].GetTicker))
        exchanges[i].SetPrecision(params["arrPricePrecision"][i], params["arrAmountPrecision"][i])

    for key in params :
        if len(params[key]) < len(exchanges):
            raise "params error!"

    while True:
        tblAcc = {
            "type" : "table",
            "title": "account",
            "cols": ["账户信息"], 
            "rows": []
        }        

        tblTick = {
            "type" : "table",
            "title": "ticker",
            "cols": ["行情信息"], 
            "rows": []
        }
        for i in range(len(exchanges)): 
            process(exchanges[i], i)

        for i in range(len(exchanges)):
            tblAcc["rows"].append([json.dumps(params["arrAcc"][i])])
            tblTick["rows"].append([json.dumps(params["arrTick"][i])])

        LogStatus(_D(), "\n`" + json.dumps([tblAcc, tblTick]) + "`")
        Sleep(500)

En segundo lugar, encontrar las diferencias.

En el caso de la aplicación, el código es diferente al del artículo anterior. En realidad, la lógica de transacción es exactamente la misma, sin ningún cambio, solo que modificamos la estrategia en varias variedades, no podemos usar las variables individuales de la columna anterior como parámetros de la estrategia. Una solución más razonable es hacer los parámetros en conjuntos, los índices de cada posición de la matriz corresponden a las transacciones agregadas.

Y luego envuelvo esta parte del código de la lógica de transacción en una función.processEn el ciclo principal de la estrategia, la función se invoca iterativamente según el par de transacciones añadido, haciendo que cada par de transacciones ejecute un código lógico de transacción.

• El nombre de la red social de Twitter es "Retrogrado" (Retrogrado).

  for i in range(len(exchanges)): 
      process(exchanges[i], i)
  

• Los parámetros de la estrategia:

  params = {
      "arrBasePrice": [-1, -1, -1],           # -1
      "arrRatio": [0.05, 0.05, 0.05],         # 0.05
      "arrAcc": [],                           # _C(exchange.GetAccount)
      "arrLastCancelAll": [0, 0, 0],          # 0
      "arrMinStocks": [0.01, 0.01, 0.01],     # 0.01
      "arrPricePrecision": [2, 2, 2],         # 2
      "arrAmountPrecision": [3, 2, 2],        # 2
      "arrTick":[]
  }
  

  Este diseño permite que cada par de transacciones tenga sus propios parámetros, ya que cada transacción tiene una gran diferencia en los precios posibles, que también pueden diferir en parámetros, y a veces se requiere un ajuste de diferenciación.

• La función CancelAll

  Se puede comparar con la variación de esta función. La función simplemente modifica un poco el código y luego piensa en la intención de la modificación.

• Datos del gráfico de la barra de estado

  Se ha añadido un gráfico que muestra los datos de mercado y los datos de activos de la cuenta en la barra de estado, mostrando en tiempo real los activos y mercados correspondientes a cada objeto de intercambio.

¿No es tan sencillo, con todas estas ideas de diseño, cambiar una estrategia de Python en varias variedades?

Tres, prueba de nuevo.

Las estrategias son solo para aprendizaje de referencia, pruebas de retrospección y interés para optimizar la actualización.Dirección estratégica