Hand in Hand lernst du, wie du eine einzigartige Python-Strategie in eine vielfältige Strategie umwandeln kannst.

Einer von ihnen ist, dass man mit den Händen lehrt, wie man eine Python-Einvariante-Strategie in eine Multi-Variante-Strategie umwandelt.

In einem letzten Artikel wurde eine sehr einfache Python-Strategie implementiert:"Python-Version für die Jagd nach dem Sturz und Fall"Die Strategie, mit der man ein Konto an einem Handelspärchen steuern kann, ist sehr einfach: man will mit der gleichen Handelslogik verschiedene Handelspare steuern. Man kann mehrere Roboter erstellen, verschiedene Handelspare einrichten, um in verschiedenen Währungen zu handeln. Wenn die Strategie nicht sehr kompliziert ist, ist es angesichts der großen Flexibilität der Quantifizierungsplattformen der Erfinder sehr einfach, eine Strategie in verschiedene Strategien umzuwandeln, so dass man mehrere Trades mit nur einem Roboter erstellen kann.

Die Strategie wurde überarbeitet:

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

Zweitens: Unterschiede finden

Wenn man sich den Code anschaut, sieht man, dass er sich stark von dem Code im vorherigen Artikel unterscheidet. Tatsächlich ist die Transaktionslogik genau die gleiche, ohne dass sich etwas ändert, nur dass wir die Strategie in mehrere Varianten modifizieren, so dass wir nicht mehr die vorhergehenden einzelnen Variablen als Strategieparameter verwenden können. Eine vernünftigere Lösung ist, die Parameter in Arrays zu machen, wobei der Index jeder Position der Array dem hinzugefügten Transaktionspaar entspricht.

Dann wickeln wir diesen Teil der Transaktionslogik in eine Funktion ein.processIn der Strategie-Hauptläufe wird die Funktion auf Basis der hinzugefügten Transaktionspaare wiederholt aufgerufen, sodass jedes Transaktionspaar einmal Transaktionslogikcode ausführt.

• Ich habe mich in der letzten Sekunde mit dem Video beschäftigt, in dem ich mich mit dem Video beschäftigt habe.

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

• Strategieparameter:

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

  So entworfen, kann jeder Handelspare seine eigenen Parameter haben, da jeder Handel einen großen Unterschied in den möglichen Preisen hat, die auch in den Parametern unterschiedlich sein können, und manchmal eine Differentiations-Einstellung erforderlich ist.

• Die Funktion CancelAll

  Man kann die Veränderung dieser Funktion als eine Änderung der Funktion vergleichen. Die Funktion ändert lediglich ein Stück Code und denkt dann darüber nach, welche Absicht sie hat.

• Status-Tab-Daten

  Es wurde ein Diagramm hinzugefügt, in dem die Marktdaten und die Aktiendaten der Konten in der Status-Tabelle angezeigt werden, um die entsprechenden Vermögenswerte und Märkte für jedes Austauschobjekt in Echtzeit darzustellen.

Ist es nicht einfach, eine Python-Strategie in mehrere Varianten zu verwandeln, wenn man diese Designideen kennt?

3. Wiederholung des Tests

Die Strategien sind nur für das Lernen, das Nachprüfen und das Optimieren von Upgrades geeignet.Strategische Adresse