A mão à mão ensina-te a transformar a estratégia de variedade única em Python em uma estratégia de variedade múltipla.

Primeiro, a mão a mão ensina-nos a transformar a política de variedade única em Python em uma política de variedade múltipla.

O artigo anterior mostra uma estratégia Python muito simples:"Estratégias de caça e queda em Python"A estratégia é muito simples, é simples, é simples. Às vezes, queremos usar a mesma lógica de negociação para operar pares de transações diferentes. É possível criar vários robôs, configurando diferentes pares de transações, para negociar em várias moedas.

O código-fonte da estratégia foi alterado:

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

Segundo, encontrar a diferença.

Em comparação com o código, será que o código encontrado é muito diferente do código do artigo anterior? Na verdade, a lógica de transação é exatamente a mesma, sem nenhuma alteração, apenas modificamos a estratégia em várias variedades, não podemos usar a variável única anterior como um parâmetro de estratégia. Uma solução mais razoável é fazer os parâmetros em conjuntos, onde o índice de cada posição da matriz corresponde ao par de transações adicionadas.

Então, vamos envolver essa parte do código da lógica de transação numa função.processNo ciclo principal da estratégia, a função é chamada de modo a que cada par de transações execute um código lógico de transação baseado no par de transações adicionado.

• O blogueiro, que também escreveu sobre o assunto, disse que o blogueiro não tem nada a ver com o assunto.

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

• Parâmetros da estratégia:

  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":[]
  }
  

  Assim, cada par de transações pode ter seus próprios parâmetros, pois cada par de transações pode ter uma grande diferença de preços possíveis, pode ser diferente em parâmetros e, às vezes, precisa de um ajuste de diferenciação.

• Função CancelAll

  A função é apenas uma modificação de um pouco de código, e depois pensar sobre a intenção de tal modificação.

• Dados do gráfico da barra de estado

  Adicionou-se um gráfico que mostra dados de mercado e dados de ativos de conta no painel de status, mostrando os ativos e mercados correspondentes a cada objeto de troca em tempo real.

Com todas essas ideias de design, não é fácil modificar uma estratégia Python para várias variedades?

Terceiro, testes de repetição.

A estratégia é apenas para aprendizagem de referência, testes de retrospectiva, interessados em otimizar a atualização.Endereço estratégico