La main à la main vous apprend à transformer une stratégie de variété unique en Python en une stratégie de variété multiple.

Premièrement, les mains en main vous apprennent à transformer une stratégie de variété unique en Python en une stratégie de variété multiple.

L'article précédent a mis en œuvre une stratégie Python très simple:"Une stratégie de chasse et de chute en Python"Cette stratégie permet d'utiliser un compte pour effectuer des transactions programmées sur une paire de transactions. Le principe est simple, c'est-à-dire de chasser. Parfois, nous voulons utiliser la même logique de transaction pour effectuer différentes paires de transactions.

Le code source de la stratégie a été modifié:

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

Deuxièmement, trouvez la différence.

Si vous regardez le code en face, vous trouverez-il une grande différence par rapport au code de l'article précédent? En fait, la logique de transaction est exactement la même, sans aucune modification, mais nous avons modifié la stratégie en plusieurs variétés, et nous ne pouvons plus utiliser les variables individuelles précédentes comme paramètres de stratégie. Une solution plus raisonnable est de faire des paramètres en ensembles, l'index de chaque position correspondant à la transaction ajoutée.

Et puis envelopper cette partie du code de la logique transactionnelle dans une fonction.processDans le cas d'un cycle principal de stratégie, la fonction est appelée selon l'irrégularité de la paire de transactions ajoutée, ce qui permet à chaque paire de transactions d'exécuter un code logique de transaction.

• Il y a aussi des gens qui ont été victimes de violences physiques.

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

• Paramètres de stratégie:

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

  Cette conception permet à chaque paire de transactions d'avoir ses propres paramètres, car chaque transaction a une grande différence de prix possibles, qui peut également varier en paramètres, parfois nécessitant des paramètres de différenciation.

• La fonction CancelAll

  On peut comparer la modification de cette fonction. Cette fonction modifie simplement un peu de code, puis réfléchit à l'intention de la modification.

• Données du graphique de la barre de statut

  Des graphiques de données de marché et de données d'actifs de compte ont été ajoutés à la barre d'état pour afficher en temps réel les actifs et les marchés correspondant à chaque objet d'échange.

Avec ces idées de conception, est-il facile de modifier une stratégie Python en plusieurs variantes?

Troisièmement, les tests sont répétés.

Les stratégies sont uniquement destinées à l'apprentissage de référence, aux tests de retouche et à l'optimisation des mises à niveau.Adresse stratégique