Der Kryptowährungsmarkt bietet ein einzigartiges Handelsumfeld und damit ideale Anwendungsmöglichkeiten für Grid-Trading-Strategien. Im Vergleich zu traditionellen Finanzmärkten ist der Kryptowährungssektor rund um die Uhr aktiv, mit kontinuierlichen und häufigen Preisschwankungen, die zahlreiche Arbitragemöglichkeiten für Grid-Strategien schaffen. Wichtige Handelsinstrumente wie Spot- und Perpetual-Kontrakte unterliegen zudem keinen Verfallsbeschränkungen, sodass Händler Positionen langfristig halten können, ohne sich um das Risiko eines Vertragsablaufs sorgen zu müssen. Die hohe Volatilität und die relativ hohe Liquidität des Kryptowährungsmarktes bieten zudem günstige Bedingungen für die Umsetzung von Grid-Strategien.

Gerade aufgrund dieser Eigenschaften weisen Grid-Trading-Strategien eine hohe Anwendbarkeit und ein hohes Gewinnpotenzial im Kryptowährungsmarkt auf. Grid-Trading ist eine weit verbreitete Strategie im Kryptowährungsmarkt, die es Händlern ermöglicht, von der Marktvolatilität zu profitieren, ohne die Marktrichtung vorhersagen zu müssen. Durch die Platzierung von Kauf- und Verkaufsaufträgen in unterschiedlichen Preisspannen ermöglicht Grid-Trading Händlern, sowohl bei steigenden als auch bei fallenden Preisen Gewinne zu erzielen.

Grid-Trading-Strategien gibt es in vielen Varianten. Dieser Artikel erläutert nur kurz einige Formate, um Anfängern den Einstieg in diese klassische quantitative Handelsmethode zu erleichtern. Die Kernidee einer Grid-Trading-Strategie besteht darin, eine Reihe von Kauf- und Verkaufsaufträgen zu unterschiedlichen Preisniveaus zu platzieren. Kaufaufträge werden erteilt, wenn der Preis die unteren Knoten des Grids erreicht, und Verkaufsaufträge werden erteilt, wenn der Preis die oberen Knoten erreicht, wodurch kleine Gewinne aus Marktschwankungen erzielt werden. Der Vorteil dieser Strategie besteht darin, dass Händler die Marktrichtung nicht vorhersagen müssen; sie verlassen sich auf Marktpreisschwankungen innerhalb des Grids.

Grundsätze der Netzstrategie

Schlüsselelemente des traditionellen Netzhandels

• Gitterknoten:Voreingestellte Preispunkte, zu denen Kauf- oder Verkaufsaufträge erteilt werden.
• Rasterabstand:Der Preisabstand zwischen benachbarten Gitterknoten bestimmt, wie stark der Preis schwanken muss, um eine Transaktion auszulösen.
• Rastergröße:Die Gesamtzahl der Gitterknoten steuert den von der Strategie abgedeckten Preisbereich.

So funktionieren Grid-Trading-Strategien

• Wenn der Preis von einem niedrigen Niveau aus steigt und den festgelegten Rasterknoten durchbricht, wird eine Verkaufsorder ausgelöst.
• Wenn der Preis von einem hohen Niveau zurückfällt und den festgelegten Rasterknoten durchbricht, wird eine Kauforder ausgelöst.
• Indem Sie in unterschiedlichen Bereichen ständig „niedrig kaufen und hoch verkaufen“, können Sie, selbst wenn der Preis innerhalb des Bereichs hin und her schwankt, aus jeder Schwankung einen Gewinn erzielen.

Beispiel

Angenommen, eine Rasterstrategie ist mit einem Rasterintervall von 8.000 bis 9.000 US-Dollar und einem Rasterintervall von 500 US-Dollar festgelegt. Steigt der Preis von 8.000 auf 8.500 US-Dollar, kauft die Strategie bei 8.000 US-Dollar und verkauft bei 8.500 US-Dollar. Steigt der Preis weiter auf 9.000 US-Dollar, verkauft sie einen Teil ihrer Bestände wieder. Fällt der Preis von 9.000 auf 8.500 US-Dollar, kauft sie erneut. Durch Wiederholung dieses Prozesses kann die Strategie trotz Marktschwankungen kontinuierlich Gewinne erzielen.

Vergleich zwischen Grid-Trading-Strategie und Balanced-Trading-Strategie

Der Kern einer ausgewogenen Strategie besteht darin, ein festes Verhältnis von Vermögenswerten beizubehalten, beispielsweise 50 % digitale Währung und 50 % Fiat-Währung. Steigt der Preis einer Kryptowährung und übersteigt der Anteil der gehaltenen Kryptowährung 50 %, wird sie verkauft; fällt der Preis, wird sie gekauft. Dadurch wird sichergestellt, dass der Wert der gehaltenen Vermögenswerte nahe dem festen Verhältnis bleibt. Unabhängig von Marktschwankungen hält eine ausgewogene Strategie einen bestimmten Anteil an Kryptowährungen.

Gemeinsamkeiten und Unterschiede zwischen Netzstrategie und Bilanzstrategie

• Ähnlichkeiten:Beide profitieren von der Volatilität, indem sie günstig kaufen und teuer verkaufen. Die Strategie kann einen Wert realisieren, wenn der Markt zu seinem ursprünglichen Preis zurückkehrt.
• Unterschiede:Grid-Strategien funktionieren nur innerhalb einer festgelegten Preisspanne, während Balanced-Strategien unabhängig von bestimmten Preisspannen sind. Eine Grid-Strategie kann den Handel möglicherweise nicht fortsetzen, wenn der Preis außerhalb der Spanne liegt, während eine Balanced-Strategie einen konstanten Kauf und Verkauf ermöglicht und so die Liquidität aufrechterhält.

Vertrag: Arithmetische Rasterstrategie

Die Arithmetische-Grid-Strategie ist eine klassische quantitative Handelsstrategie, die häufig in volatilen Märkten eingesetzt wird. Diese Strategie nutzt die Gewinne aus Preisschwankungen, indem Kauf- und Verkaufsaufträge in festen Preisintervallen (arithmetischen Intervallen) platziert werden. Sie eignet sich für Märkte mit hoher Volatilität, aber unvorhersehbarer Entwicklung, wie beispielsweise Kryptowährungen und bestimmte Terminkontrakte.

Kernlogik

Kernkonzepte:

1. äquidistantes Intervall
   Bei der arithmetischen Rasterstrategie besteht eine Lücke zwischen den Kauf- und Verkaufspreisen.Festpreisintervalle, das im Code stehtgridWenn der Preis beispielsweise um 300 Einheiten schwankt (wie im Codegrid=300), wird eine Kauf- oder Verkaufsorder ausgelöst.

2. Rasterinitialisierung
   Die Strategie generiert die anfänglichen Kauf- und Verkaufspreise basierend auf dem aktuellen Preis, diebuyp Und sellpDie beiden Preisintervalle basieren auf dem RasterintervallgridZum Einstellen, jeweils über und unter dem aktuellen PreisgridEinheiten.

3. Gewinn mitnehmen und umkehren
   Wenn der Preis in einen bestimmten Bereich steigt, kauft die Strategie im Long-Positionsbereich und platziert eine Verkaufsorder zur Gewinnmitnahme. Steigt der Preis weiter in den umgekehrten Positionsbereich (upper), wird die Long-Position Gewinne mitnehmen und eine Short-Position eingehen und umgekehrt.

4. Positionsmanagement innerhalb des Rasters
   Jede Kauf- oder Verkaufsaktion innerhalb des Rasters wird ausgelöst, wenn der Preis den voreingestellten Wert erreicht.buyp oder sellpNach jeder Transaktion passt das System die nächste Gruppe von Kauf- und Verkaufspreisen automatisch an, um ein festes Rasterintervall einzuhalten.

5. Hinzufügen und Reduzieren von Positionen
   Die Strategie passt ihre Position kontinuierlich an den Rasterpreis an. Erreicht der Preis den Kaufpunkt, erhöht sie ihre Position (erhöht ihre Position); erreicht der Preis den Verkaufspunkt, reduziert sie ihre Position schrittweise (verringert ihre Position). Durch wiederholtes Kaufen und Verkaufen erfasst sie jede kleine Marktschwankung.

Strategiecode

'''backtest
start: 2024-08-26 00:00:00
end: 2024-09-25 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2500}]
args: [["H",30],["n1",0.001],["grid",300],["bottom",50000]]
'''

# 交易参数配置（设为策略参数）
M = 20          # 杠杆大小
H = 50          # 初始底仓份数
n1 = 1          # 单个网格交易数量
grid = 200      # 单个网格交易间距
bottom = 35000  # 开多点位
upper = 60000   # 开空点位

def CancelPendingOrders():
    orders = _C(exchanges[0].GetOrders)
    if len(orders)>0:
        for j in range(len(orders)):
            exchanges[0].CancelOrder(orders[j].Id, orders[j])
            j=j+1

def main():
    exchange.SetContractType('swap')
    exchange.SetMarginLevel(M)
    currency=exchange.GetCurrency()
    if _G('buyp') and _G('sellp'):
        buyp=_G('buyp')
        sellp=_G('sellp')
        Log('读取网格价格')
    else:
        ticker=exchange.GetTicker()
        buyp=ticker["Last"]-grid
        sellp=ticker["Last"]+grid
        _G('buyp',buyp)
        _G('sellp',sellp)
        Log('网格数据初始化')
    while True:
        account=exchange.GetAccount()
        ticker=exchange.GetTicker()
        position=exchange.GetPosition()
        orders=exchange.GetOrders()
        if len(position)==0:
            if ticker["Last"]>upper:
                exchange.SetDirection('sell')
                exchange.Sell(-1,n1*H)
                Log(currency,'到达开空区域,买入空头底仓')
                
            else:
                exchange.SetDirection('buy')
                exchange.Buy(-1,n1*H)
                Log(currency,'到达开多区域,买入多头底仓')
        if len(position)==1:
            if position[0]["Type"]==1: #持有空头仓位
                if ticker["Last"]<bottom:
                    Log(currency,'空单全部止盈反手')
                    exchange.SetDirection('closesell')
                    exchange.Buy(-1,position[0].Amount)
                else: 
                    orders=exchange.GetOrders()
                    if len(orders)==0: 
                        exchange.SetDirection('sell')
                        exchange.Sell(sellp,n1)
                        exchange.SetDirection('closesell')
                        exchange.Buy(buyp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==1: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==0:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
        
            if position[0]["Type"]==0:
                if ticker["Last"]>float(upper):
                    Log(currency,'多单全部止盈反手')
                    exchange.SetDirection('closebuy')
                    exchange.Sell(-1,position[0].Amount)
                else:
                    orders=exchange.GetOrders()
                    if len(orders)==0:
                        exchange.SetDirection('buy')
                        exchange.Buy(buyp,n1)
                        exchange.SetDirection('closebuy')
                        exchange.Sell(sellp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==0: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==1:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])

Die arithmetische Rasterstrategie ist im Kryptowährungsmarkt, insbesondere in volatilen, aber unvorhersehbaren Märkten, sehr anwendbar. Durch die Platzierung von Kauf- und Verkaufsaufträgen in festen Preisintervallen erfasst diese Strategie effektiv Marktschwankungen und behält gleichzeitig automatisierte Abläufe und einfache Logik bei. Die hohe Volatilität des Kryptowährungsmarktes bietet gute Chancen für den Erfolg dieser Strategie.

Es ist zu beachten, dass die Transaktionskosten einer arithmetischen Rasterstrategie hauptsächlich durch häufige Kauf- und Verkaufsaufträge entstehen, nicht durch deren Platzierung oder Stornierung. Diese Eigenschaft erfordert besondere Aufmerksamkeit bei Kryptowährungsbörsen mit hohen Transaktionsgebühren. Um die Rendite zu optimieren, empfiehlt es sich, Börsen mit niedrigeren Gebühren zu wählen und das Rasterintervall und die Fondsallokationsquote an die spezifischen Marktbedingungen anzupassen.

Insgesamt eignet sich die arithmetische Rasterstrategie gut für den volatilen Kryptowährungsmarkt, kann aber in unilateralen Märkten erhebliche Risiken bergen. Durch die richtige Festlegung der Parameter und die Optimierung des Fondsmanagements können die Robustheit und Rentabilität der Strategie effektiv verbessert werden.

Spot: Dynamische Netzstrategie

Dynamische NetzstrategieAnders als bei der traditionellen FestnetzstrategieDynamische GenerierungUndAnpassen von Mesh-KnotenDiese Strategie ermöglicht eine größere Flexibilität bei Marktschwankungen. Sie generiert neue Grid-Knoten basierend auf Echtzeit-Marktschwankungen und verbessert so die Anpassungsfähigkeit und Risikokontrolle der Strategie. Das Kernkonzept besteht darin, nur dann neue Knoten zu generieren, wenn die Preisschwankungen einen bestimmten Schwellenwert überschreiten, und Positionen entsprechend zu verwalten.

Kernfunktionen

1. Dynamische Netzknotengenerierung：

   • Der Marktpreis durchbricht den vorherigen Gitterknoten und die Schwankungsbreite überschreitet den vorgegebenen Bereich (um_GridPointDisSteuerung) generiert die Strategie neue Gitterknoten.
   • Jeder Grid-Knoten erfasst die aktuellen Preis- und Positionsinformationen und legt die Abschlussbedingungen fest (durch_GridCovDisKontrollierte Schlussspanne).

2. Kauf- und Verkaufsvorgänge：

   • Lange Richtung（direction = 1): Wenn der Preis steigt und den Gitterknoten durchbricht, verkaufen Sie die Vermögenswerte, die Sie gehalten haben; wenn er wieder fällt, kaufen Sie erneut.
   • Kurze Richtung（direction = -1): Wenn der Preis fällt und den Gitterknoten durchbricht, kaufen Sie den Vermögenswert; wenn er sich erholt, verkaufen Sie den gehaltenen Vermögenswert.

3. Schließvorgang：

   • Wenn der Preis den festgelegten Schlusskurs erreicht (_GridCovDisSetzen Sie die Position, führen Sie Rückkauf- (bei Long-Positionen) oder Verkaufsvorgänge (bei Short-Positionen) entsprechend der aktuellen Richtung aus, um die Schließung der Position abzuschließen.

4. Maschenmengenkontrolle：

   • Wenn die Anzahl der Rasterknoten den maximalen Einstellwert überschreitet (_GridNum), löscht die Strategie automatisch den frühesten Rasterknoten, wodurch übermäßige Positionen vermieden und Risiken reduziert werden.

Kernlogik

1. Initialisierungsparameter：

   • _GridNum: Maximale Anzahl von Rasterknoten, die maximale Anzahl von Rasterknoten, die die Steuerungsstrategie gleichzeitig halten kann.
   • _GridPointAmount: Die Bestellmenge jedes Rasterknotens.
   • _GridPointDis: Der Preisabstand zwischen den Rasterknoten.
   • _GridCovDis: Die Preisdifferenz zum Schließen einer Position. Wenn die Schwankung zwischen Marktpreis und Grid-Preis diese Preisdifferenz übersteigt, wird die Position geschlossen.

2. UpdateGrid-Funktion：

   • Basierend auf dem aktuellen Preis (current_price), Kaufpreis (bids_price) und dem Verkaufspreis (asks_price) aktualisiert die Grid-Knoten. Immer wenn der Marktpreis einen Grid-Knoten durchbricht, generiert die Strategie einen neuen Grid-Knoten und führt den entsprechenden Handel aus.
   • Prüfen Sie, ob die Schließbedingungen erfüllt sind und führen Sie den Schließvorgang bei Erfüllung aus.
   • Steuert die maximale Anzahl der Rasterknoten. Wenn die maximale Anzahl überschritten wird, werden die ältesten Rasterknoten gelöscht.

3. Hauptschleife：

   • mainDie Funktion erhält kontinuierlich Echtzeit-Marktpreisdaten und ruftUpdateGridFunktionen aktualisieren Grid-Knoten und führen Handelsoperationen durch.
   • passierenLogStatusZeichnen Sie den aktuellen Netzstatus, Kontoinformationen usw. auf, um die Echtzeitüberwachung des Strategiebetriebs zu ermöglichen.

Strategiecode (erfordert Python-Spot- und Zeichnungsvorlagenreferenzen)

'''backtest
start: 2024-04-01 00:00:00
end: 2024-09-23 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"ETH_USDT"}]
'''

direction = 1  # 网格方向：1表示向上，-1表示向下
_GridNum = 10  # 网格节点数量
_GridPointAmount = 0.1  # 每个网格节点的下单量
_GridPointDis = 100  # 网格节点之间的价格间距
_GridCovDis = 150  # 平仓价与网格节点的差距
_Grid = []  # 网格数据列表

def UpdateGrid(nowBidsPrice, nowAsksPrice, direction):  # up 1, down -1
    global _Grid

    # 检查是否需要创建新的网格节点
    if len(_Grid) == 0 or (direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis) or \
            (direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis):
        
        if len(_Grid) == 0:
            Log('策略起始')
        if len(_Grid) != 0 and direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis:
            Log('向上突破，突破阈值：', nowBidsPrice - _Grid[-1]['price'])
        if len(_Grid) != 0 and direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis:
            Log('向下突破，突破阈值：', _Grid[-1]['price'] - nowAsksPrice)

        # 根据方向决定当前网格节点的价格
        nowPrice = nowBidsPrice if direction == 1 else nowAsksPrice
        _Grid.append({
            'price': nowPrice if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction,
            'hold': {'price': 0, 'amount': 0},
            'coverPrice': (nowPrice - direction * _GridCovDis) if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction - direction * _GridCovDis
        })

        Log('网格更新数量：', len(_Grid), '网格最新增添：', _Grid[-1])

        # 下单操作，向上突破时卖出，向下突破时买入
        tradeInfo = ext.Sell(_GridPointAmount) if direction == 1 else ext.Buy(_GridPointAmount)
        _Grid[-1]['hold']['price'] = tradeInfo['price']
        _Grid[-1]['hold']['amount'] = tradeInfo['amount']

        Log('网格操作：', '向上卖出' if direction == 1 else '向下买入')

    # 检查是否需要平仓
    if len(_Grid) > 0 and (
            (direction == 1 and nowAsksPrice < _Grid[-1]['coverPrice']) or 
            (direction == -1 and nowBidsPrice > _Grid[-1]['coverPrice'])):

        coverInfo = ext.Buy(_Grid[-1]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[-1]['hold']['amount'])
        Log('价格跌破平仓价格，买入，去除最后添加网格' if direction == 1 else '价格突破平仓价格，卖出，去除最后添加网格')

        _Grid.pop()  # 移除已平仓的网格节点
    
    # 如果网格数量超出设定值，则平掉最早的网格节点
    elif len(_Grid) > _GridNum:
        coverFirstInfo = ext.Buy(_Grid[0]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[0]['hold']['amount'])
        Log('网格数量过多，买入操作，去除初始网格' if direction == 1 else '网格数量过多，卖出操作，去除初始网格')
        _Grid.pop(0)

def main():
    global _Grid
    while True:
        ticker = _C(exchange.GetTicker)
        records = _C(exchange.GetRecords)
        ext.PlotRecords(records, "kline")
        UpdateGrid(ticker['Buy'], ticker['Sell'], direction)

        # 记录当前网格状态
        msg = ""
        for grid in _Grid:
            msg += str(grid) + "\n"
        
        LogStatus(_D(), _C(exchange.GetAccount), "\n", "_Grid.length:", len(_Grid), "_GridNum:", _GridNum, "\n", msg)
        Sleep(500)

Hinweis:

1. Damit jeder den Rastergenerierungsprozess versteht, werden dem Code viele Kommentare hinzugefügt, die in der tatsächlichen Anwendung gelöscht werden können.
2. Um den Handel zu erleichtern, verwendet die Spot-Strategie die Spot-Template-Handelsbibliothek. Sie können den Quellcode einsehen, um mehr darüber zu erfahren.
3. Bei der Anwendung auf den realen Handel muss es entsprechend den Merkmalen der verschiedenen Börsen verbessert werden.

Futures: Long-Short Bidirektionale Grid-Strategie

Die Long-Short Bidirectional Grid-Strategie ist eine komplexere, aber leistungsfähigere Grid-Variante, die gleichzeitigen Handel in Long- und Short-Richtung ermöglicht und so die Gewinnchancen in volatilen Märkten maximiert. Im Kern passt diese Strategie Positionen dynamisch an Preisabweichungen vom Ausgangspreis an und erreicht so eine wirklich marktneutrale Strategie.

Kernfunktionen

1. Langer und kurzer Modus: Unabhängig davon, ob der Preis steigt oder fällt, kann die Strategie Gewinne erzielen, indem sie in die entsprechende Richtung operiert
2. Dynamische Positionsanpassung：Berechnen Sie die Zielposition basierend auf dem Verhältnis der Preisabweichung vom Anfangspreis
3. Zweiseitige Rasterreihenfolge: Legen Sie Kauf- und Verkaufsaufträge gleichzeitig fest, um Preisschwankungen in beide Richtungen zu erfassen
4. Risikokontrolle：Reduzieren Sie einseitige Risiken durch vernünftiges Positionsmanagement und Auftragskontrolle

Strategielogik

Die Kernlogik der Strategie besteht darin, die Zielposition anhand des Abweichungsgrads zwischen dem Preis und dem Anfangspreis zu bestimmen:

• Wenn der Preis steigt, ist die Zielposition negativ (Short), und je stärker der Preis steigt, desto größer ist die Short-Position.
• Bei fallendem Kurs ist die Zielposition positiv (Long). Je stärker der Kurs fällt, desto größer ist die Long-Position.
• Schrittweise Anpassung der Ist-Position an die Zielposition durch die Ausführung von Grid-Orders

Strategiecode

import time
import math

# 全局变量初始化
InitPrice = 800
Funding = 50000

# 策略参数（需要在策略页面设置）
pct = 5.0        # 网格间距百分比
value = 5000      # 每个网格的投入金额
Interval = 3     # 策略执行间隔（秒）

# 账户资产信息
assets = {
    'USDT': {
        'total_balance': 0,
        'margin_balance': 0,
        'margin': 0,
        'unrealised_profit': 0
    }
}

def init():
    """初始化策略"""
    global symbol, Funding, base_currency
    
    Log('交易模式：多空都做')
    
    # 设置合约类型
    exchange.SetContractType('swap')
    
    # 获取交易币种
    currency = exchange.GetCurrency()
    symbol = currency  # 保持原格式，如 "BTC_USDT"
    base_currency = symbol.split('_')[0]  # 获取基础币种，如 "BTC"
    Log('交易币种：', symbol)
    Log('基础币种：', base_currency)

    swapcode = symbol + '.swap'
    ticker = exchange.GetTicker(swapcode)  # 回测系统需要
    exchange_info = exchange.GetMarkets()
    data = exchange_info.get(swapcode)
    
    # 初始化资产信息
    assets[base_currency] = {
        'amount': 0,
        'price': 0,
        'hold_price': 0,
        'price': 0,
        'unrealised_profit': 0,
        'leverage': 20,
        'liquidation_price': 0,
        'AmountPrecision': data['AmountPrecision'],
        'PricePrecision': data['PricePrecision'],
        'MinQty': data['MinQty']
    }
    
    # 撤销所有挂单
    cancel_all_orders()
    
    # 获取初始资金
    account = exchange.GetAccount()
    if account:
        Funding = account.Balance + account.FrozenBalance
        Log('初始资金：', Funding)

def calculate_grid_orders():
    """计算网格订单"""
    if InitPrice == 0 or assets[base_currency]['price'] == 0:
        return None
    
    current_price = assets[base_currency]['price']
    current_amount = assets[base_currency]['amount']
    
    # 多空都做模式：根据价格变化计算目标持仓
    price_change_ratio = (current_price - InitPrice) / InitPrice
    target_amount = -price_change_ratio * (value / pct) / current_price
    
    # 计算买卖价格
    grid_spacing = current_price * (pct / 100)  # 网格间距
    buy_price = current_price - grid_spacing
    sell_price = current_price + grid_spacing
    
    # 计算订单数量
    order_amount = value / current_price
    
    return {
        'buy_price': round(buy_price, assets[base_currency]['PricePrecision']),
        'sell_price': round(sell_price, assets[base_currency]['PricePrecision']),
        'buy_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
        'sell_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
        'target_amount': target_amount
    }

def execute_strategy():
    """执行交易策略"""
    # 计算网格订单
    grid_info = calculate_grid_orders()
    if not grid_info:
        return
    
    current_amount = assets[base_currency]['amount']
    target_amount = grid_info['target_amount']
    amount_diff = target_amount - current_amount
    
    # 如果持仓偏离较大，先调整持仓
    if abs(amount_diff) > assets[base_currency]['MinQty']:
        cancel_all_orders()
        Sleep(500)
        
        # 判断需要的操作
        if amount_diff > 0:
            # 需要增加多头持仓或减少空头持仓
            if current_amount >= 0:
                # 当前是多头或空仓，直接开多
                Log(f'当前持仓：{current_amount}，需要开多：{abs(amount_diff):.6f}')
                open_position('LONG', assets[base_currency]['price'], abs(amount_diff))
            else:
                # 当前是空头，需要先平空再开多
                if abs(amount_diff) <= abs(current_amount):
                    # 只需要平掉部分空仓
                    Log(f'当前空仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                    safe_close_position(abs(amount_diff), assets[base_currency]['price'])
                else:
                    # 需要平掉所有空仓，然后开多
                    Log(f'平掉所有空仓：{abs(current_amount):.6f}')
                    if safe_close_position(abs(current_amount), assets[base_currency]['price']):
                        Sleep(1000)  # 等待平仓完成
                        
                        # 更新持仓信息
                        update_account()
                        remaining_amount = abs(amount_diff) - abs(current_amount)
                        if remaining_amount > assets[base_currency]['MinQty']:
                            Log(f'开多剩余数量：{remaining_amount:.6f}')
                            open_position('LONG', assets[base_currency]['price'], remaining_amount)
        
        elif amount_diff < 0:
            # 需要增加空头持仓或减少多头持仓
            if current_amount <= 0:
                # 当前是空头或空仓，直接开空
                Log(f'当前持仓：{current_amount}，需要开空：{abs(amount_diff):.6f}')
                open_position('SHORT', assets[base_currency]['price'], abs(amount_diff))
            else:
                # 当前是多头，需要先平多再开空
                if abs(amount_diff) <= current_amount:
                    # 只需要平掉部分多仓
                    Log(f'当前多仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                    safe_close_position(abs(amount_diff), assets[base_currency]['price'])
                else:
                    # 需要平掉所有多仓，然后开空
                    Log(f'平掉所有多仓：{current_amount:.6f}')
                    if safe_close_position(current_amount, assets[base_currency]['price']):
                        Sleep(1000)  # 等待平仓完成
                        
                        # 更新持仓信息
                        update_account()
                        remaining_amount = abs(amount_diff) - current_amount
                        if remaining_amount > assets[base_currency]['MinQty']:
                            Log(f'开空剩余数量：{remaining_amount:.6f}')
                            open_position('SHORT', assets[base_currency]['price'], remaining_amount)
    
    # 检查是否需要重新挂网格单
    orders = exchange.GetOrders()
    if not orders or len(orders) < 2:  # 多空都做模式需要2个订单
        cancel_all_orders()
        Sleep(500)
        
        # 重新获取最新持仓信息
        update_account()
        current_amount = assets[base_currency]['amount']
        
        # 挂买单和卖单（网格订单）
        buy_amount = grid_info['buy_amount']
        sell_amount = grid_info['sell_amount']
        
        # 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
        place_grid_orders(current_amount, grid_info, buy_amount, sell_amount)

def place_grid_orders(current_amount, grid_info, buy_amount, sell_amount):
    """放置网格订单 - 多空都做模式"""
    Log(f'放置网格订单 - 当前持仓：{current_amount}')
    
    # 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
    Log(f'多空都做模式 - 挂开多单：数量={buy_amount:.6f}，价格={grid_info["buy_price"]}')
    open_position('LONG', grid_info['buy_price'], buy_amount)
    Sleep(200)
    Log(f'多空都做模式 - 挂开空单：数量={sell_amount:.6f}，价格={grid_info["sell_price"]}')
    open_position('SHORT', grid_info['sell_price'], sell_amount)

def cancel_all_orders():
    """撤销所有未成交订单"""
    try:
        orders = exchange.GetOrders()
        if orders:
            for order in orders:
                exchange.CancelOrder(order['Id'])
                Sleep(100)  # 避免频繁操作
        return True
    except Exception as e:
        Log('撤单异常：', str(e))
        return False

def get_real_position():
    """获取真实持仓信息"""
    try:
        positions = exchange.GetPosition()
        if positions:
            for pos in positions:
                if pos['ContractType'] == 'swap' and pos['Amount'] > 0:
                    position_amount = pos['Amount'] * (1 if pos['Type'] == 0 else -1)
                    return position_amount, pos['Price'], pos['Profit']

        return 0, 0, 0
    except Exception as e:
        Log('获取持仓异常：', str(e))
        return 0, 0, 0

def update_account():
    """更新账户信息"""
    try:
        account = exchange.GetAccount()
        if not account:
            Log('获取账户信息失败')
            return False
        
        # 更新USDT资产信息
        assets['USDT']['total_balance'] = account.Balance + account.FrozenBalance
        assets['USDT']['margin_balance'] = account.Balance
        
        # 获取真实持仓信息
        position_amount, hold_price, profit = get_real_position()
        assets[base_currency]['amount'] = position_amount
        assets[base_currency]['hold_price'] = hold_price
        assets[base_currency]['unrealised_profit'] = profit
        
        return True
    except Exception as e:
        Log('更新账户异常：', str(e))
        return False

def update_price():
    """更新行情价格"""
    global InitPrice
    
    ticker = exchange.GetTicker()
    if not ticker:
        Log('获取行情失败')
        return False
    
    # 设置初始价格
    if InitPrice == 0:
        InitPrice = ticker.Last
        Log('设置初始价格：', InitPrice)
    
    assets[base_currency]['price'] = ticker.Last
    return True

def create_order(side, price, amount, order_type="开仓"):
    """使用CreateOrder下单函数"""
    try:
        if amount <= 0:
            Log(f'订单数量无效：{amount}')
            return False
        
        # 构造期货合约symbol
        contract_symbol = f"{symbol}.swap"
        
        # 下单
        order_id = exchange.CreateOrder(contract_symbol, side, price, amount)
        
        if order_id:
            Log(f'{order_type} {side} 下单成功：价格={price}, 数量={amount}, 订单ID={order_id}')
            return order_id
        else:
            Log(f'{order_type} {side} 下单失败：价格={price}, 数量={amount}')
            return False
            
    except Exception as e:
        Log('下单异常：', str(e))
        return False

def safe_close_position(close_amount, price=-1):
    """安全平仓函数"""
    try:
        if close_amount <= 0:
            Log(f'平仓数量无效：{close_amount}')
            return False
        
        # 实时获取持仓信息
        current_position, _, _ = get_real_position()
        
        # 检查是否真的有持仓
        if current_position == 0:
            Log('当前无持仓，跳过平仓操作')
            return False
        
        # 检查平仓数量是否超过持仓
        if abs(close_amount) > abs(current_position):
            Log(f'平仓数量超过持仓：持仓{current_position}，平仓{close_amount}，调整为持仓数量')
            close_amount = abs(current_position)
        
        # 根据当前持仓方向确定平仓操作
        if current_position > 0:  # 当前是多仓
            side = "closebuy"  # 平多仓
            Log(f'平多仓：数量={close_amount}，价格={price}')
        else:  # 当前是空仓
            side = "closesell"  # 平空仓
            Log(f'平空仓：数量={close_amount}，价格={price}')
        
        return create_order(side, price, close_amount, "平仓")
        
    except Exception as e:
        Log('平仓异常：', str(e))
        return False

def open_position(direction, price, amount):
    """开仓函数"""
    try:
        if amount <= 0:
            Log(f'开仓数量无效：{amount}')
            return False
        
        # 确定开仓方向
        if direction == 'LONG':
            side = "buy"  # 开多仓
            Log(f'开多仓：数量={amount}，价格={price}')
        else:  # SHORT
            side = "sell"  # 开空仓
            Log(f'开空仓：数量={amount}，价格={price}')
        
        return create_order(side, price, amount, "开仓")
        
    except Exception as e:
        Log('开仓异常：', str(e))
        return False

def update_status():
    """更新状态显示"""
    try:
        if Funding > 0:
            current_balance = assets['USDT']['total_balance']
            profit = current_balance - Funding
            profit_rate = (profit / Funding) * 100
            
            status_info = f"""
策略状态 - {symbol}
交易模式: 多空都做
当前价格: {assets[base_currency]['price']}
初始价格: {InitPrice}
持仓数量: {assets[base_currency]['amount']}
持仓价格: {assets[base_currency]['hold_price']}
账户余额: {current_balance:.4f} USDT
总收益: {profit:.4f} USDT ({profit_rate:.2f}%)
未实现盈亏: {assets[base_currency]['unrealised_profit']:.4f} USDT
"""
            LogStatus(status_info)
    
    except Exception as e:
        Log('状态更新异常：', str(e))

def main():
    """主函数"""
    # 设置错误过滤
    SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused|Unknown")
    
    # 初始化
    init()
    
    Log('策略启动成功')
    
    while True:
        try:
            # 更新账户信息
            if not update_account():
                Log('更新账户信息失败，等待重试')
                Sleep(5000)
                continue
            
            # 更新价格信息
            if not update_price():
                Log('更新价格信息失败，等待重试')
                Sleep(5000)
                continue
            
            # 执行策略
            execute_strategy()
            
            # 更新状态
            update_status()
            
            # 休眠
            Sleep(Interval * 1000)
            
        except Exception as e:
            Log('主循环异常：', str(e))
            Sleep(5000)  # 发生异常时等待5秒再继续

Der Vorteil einer Long-Short-Zweiwege-Grid-Strategie liegt in ihrer Anpassungsfähigkeit an unterschiedliche Marktbedingungen. Sie ermöglicht durch entsprechende Maßnahmen profitable Renditen, unabhängig davon, ob die Kurse steigen, fallen oder volatil sind. Allerdings erfordert sie auch ein sorgfältiges Risikomanagement, insbesondere unter extremen Marktbedingungen.

Zusammenfassen

Die Flexibilität und Automatisierung von Grid-Strategien machen sie zu einem gängigen Instrument im quantitativen Handel. Verschiedene Grid-Varianten lassen sich an unterschiedliche Marktumgebungen anpassen. Jede Strategie hat ihre spezifischen Anwendungsszenarien und Vorteile. Anleger können die passende Grid-Strategie basierend auf spezifischen Marktschwankungen und ihrer persönlichen Risikobereitschaft auswählen und sie mit Instrumenten wie dynamischem Positionsmanagement sowie Stop-Loss- und Take-Profit-Strategien kombinieren, um die Effektivität der Strategie weiter zu optimieren.

brauchenveranschaulichenDie drei in diesem Artikel besprochenen Strategien stammen alle aus der Strategy Plaza der Inventor-Plattform und bieten eine Zusammenfassung. Als klassische quantitative Strategie bieten Grid-Strategien noch viel zu entdecken, beispielsweise wie man Margin Calls vermeidet und Risiken minimiert sowie die Mittelverwendung optimiert, um die Rendite zu steigern. Interessierte können die Strategy Plaza besuchen, wo Echtzeit-Grid-Strategien zum Nachschlagen und Studieren zur Verfügung stehen.