Pasaran mata wang kripto menawarkan persekitaran dagangan yang unik, mewujudkan senario aplikasi yang ideal untuk strategi perdagangan grid. Berbanding dengan pasaran kewangan tradisional, sektor mata wang kripto beroperasi ²⁴⁄₇, dengan turun naik harga yang berterusan dan kerap, mewujudkan peluang arbitraj yang banyak untuk strategi grid. Tambahan pula, instrumen dagangan utama seperti kontrak spot dan perpetual tidak mempunyai sekatan tamat tempoh, membenarkan peniaga memegang jawatan untuk jangka masa panjang tanpa bimbang tentang risiko tamat tempoh kontrak. Tambahan pula, ketidaktentuan pasaran mata wang kripto yang tinggi dan kecairan yang agak tinggi memberikan keadaan yang menggalakkan untuk melaksanakan strategi grid.

Justru kerana ciri-ciri inilah strategi perdagangan grid menunjukkan kebolehgunaan yang kukuh dan potensi keuntungan dalam pasaran mata wang kripto. Perdagangan grid ialah strategi yang digunakan secara meluas dalam pasaran mata wang kripto yang membolehkan pedagang mendapat keuntungan daripada turun naik pasaran tanpa perlu meramalkan arah pasaran. Dengan meletakkan pesanan beli dan jual pada julat harga yang berbeza, perdagangan grid membantu pedagang memperoleh keuntungan semasa harga naik dan turun.

Strategi perdagangan grid mempunyai banyak variasi. Artikel ini hanya akan membincangkan secara ringkas beberapa format untuk membantu pemula bermula dengan kaedah perdagangan kuantitatif klasik ini. Idea teras strategi perdagangan grid adalah untuk meletakkan satu siri pesanan beli dan jual pada tahap harga yang berbeza. Pesanan belian dibuat apabila harga mencapai nod bawah grid, dan pesanan jual dibuat apabila harga mencapai nod atas, dengan itu memperoleh keuntungan kecil daripada turun naik pasaran. Kelebihan strategi ini ialah peniaga tidak perlu meramal arah pasaran; mereka bergantung pada turun naik harga pasaran dalam grid.

Prinsip Strategi Grid

Elemen utama perdagangan grid tradisional

• Nod Grid:Mata harga pratetap di mana pesanan beli atau jual diletakkan.
• Jarak Grid:Jarak harga antara nod grid bersebelahan menentukan berapa banyak harga yang perlu berubah-ubah untuk mencetuskan transaksi.
• Saiz Grid:Jumlah bilangan nod grid mengawal julat harga yang diliputi oleh strategi.

Bagaimana Strategi Perdagangan Grid Berfungsi

• Apabila harga naik dari paras rendah dan menembusi nod grid yang ditetapkan, pesanan jual dicetuskan.
• Apabila harga jatuh semula dari paras tinggi dan menembusi nod grid yang ditetapkan, pesanan beli dicetuskan.
• Dengan sentiasa “membeli rendah dan menjual tinggi” dalam julat yang berbeza, walaupun harga turun naik berulang-alik dalam julat, anda masih boleh membuat keuntungan daripada setiap turun naik.

Contoh

Katakan strategi grid ditetapkan dengan selang grid \(8,000 hingga \)9,000, dengan selang grid \(500. Apabila harga meningkat daripada \)8,000 kepada \(8,500, strategi akan membeli pada \)8,000 dan menjual pada \(8,500. Jika harga meningkat lagi kepada \)9,000, ia akan menjual beberapa pegangannya semula. Apabila harga jatuh semula daripada \(9,000 kepada \)8,500, ia akan membeli semula. Dengan mengulangi proses ini, strategi boleh terus mengumpul keuntungan di tengah-tengah turun naik pasaran.

Perbandingan antara Strategi Perdagangan Grid dan Strategi Perdagangan Seimbang

Teras strategi seimbang adalah untuk mengekalkan nisbah tetap aset, seperti 50% mata wang digital dan 50% mata wang fiat. Apabila harga mata wang kripto meningkat dan perkadaran mata wang kripto yang dipegang melebihi 50%, ia dijual; apabila harga jatuh, ia dibeli. Ini memastikan bahawa nilai aset yang dipegang kekal hampir dengan nisbah tetap. Tanpa mengira turun naik pasaran, strategi yang seimbang mengekalkan sejumlah mata wang kripto tertentu.

Persamaan dan perbezaan antara strategi grid dan strategi keseimbangan

• Persamaan:Kedua-dua keuntungan daripada turun naik dengan membeli rendah dan menjual tinggi, dan strategi boleh merealisasikan nilai apabila pasaran kembali kepada harga asalnya.
• Perbezaan:Strategi grid beroperasi hanya dalam julat harga yang telah ditetapkan, manakala strategi seimbang adalah bebas daripada julat harga tertentu. Strategi grid mungkin tidak dapat meneruskan dagangan jika harga jatuh di luar julat, manakala strategi seimbang membolehkan pembelian dan penjualan berterusan, mengekalkan kecairan.

Kontrak: Strategi Grid Aritmetik

Strategi grid aritmetik ialah strategi perdagangan kuantitatif klasik yang sering digunakan dalam pasaran yang tidak menentu. Strategi ini menangkap keuntungan daripada turun naik harga dengan meletakkan pesanan beli dan jual pada selang harga tetap (selang aritmetik). Ia sesuai untuk pasaran dengan turun naik yang tinggi tetapi arah yang tidak dapat diramalkan, seperti mata wang kripto dan kontrak niaga hadapan tertentu.

Logik Teras

Konsep teras:

1. selang jarak sama
   Dalam strategi grid aritmetik, terdapat jurang antara harga beli dan jual.Selang harga tetap, yang terdapat dalam kodgridSebagai contoh, apabila harga turun naik sebanyak 300 unit (seperti dalam kodgrid=300), pesanan beli atau jual dicetuskan.

2. Permulaan grid
   Strategi menjana harga beli dan jual awal berdasarkan harga semasa, iaitubuyp dansellpDua selang harga adalah berdasarkan selang gridgridUntuk menetapkan, masing-masing di atas dan di bawah harga semasagridunit.

3. Ambil untung dan balik
   Apabila harga naik ke julat tertentu, strategi akan membeli dalam kawasan kedudukan panjang dan menetapkan pesanan jual untuk mengambil untung. Jika harga terus meningkat ke kawasan kedudukan terbalik (upper), kedudukan beli akan mengambil untung dan pergi pendek, dan sebaliknya.

4. Pengurusan kedudukan dalam grid
   Setiap tindakan beli atau jual dalam grid akan dicetuskan apabila harga mencapai pratetapbuyp atau sellpSelepas setiap transaksi, sistem secara automatik melaraskan kumpulan harga beli dan jual seterusnya untuk mengekalkan selang grid tetap.

5. Menambah dan mengurangkan kedudukan
   Strategi ini secara berterusan melaraskan kedudukannya berdasarkan harga grid. Apabila harga mencecah titik beli, ia meningkatkan kedudukannya (meningkatkan kedudukannya); apabila harga mencecah titik jualan, ia secara beransur-ansur mengurangkan kedudukannya (menurunkan kedudukannya). Dengan membeli dan menjual berulang kali, ia menangkap setiap turun naik pasaran yang kecil.

Kod Strategi

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

Strategi grid aritmetik mempunyai kebolehgunaan yang besar dalam pasaran mata wang kripto, terutamanya dalam pasaran yang tidak menentu tetapi tidak dapat diramalkan. Dengan meletakkan pesanan beli dan jual pada selang harga tetap, strategi ini berkesan menangkap turun naik pasaran sambil mengekalkan operasi automatik dan logik mudah. Kemeruapan pasaran mata wang kripto yang tinggi memberikan peluang yang baik untuk strategi ini berkembang.

Perlu diingat bahawa kos urus niaga strategi grid aritmetik terutamanya datang daripada pesanan beli dan jual yang kerap, dan bukannya meletakkan atau membatalkannya. Ciri ini memerlukan perhatian khusus pada pertukaran mata wang kripto dengan yuran transaksi yang tinggi. Untuk mengoptimumkan pulangan, adalah disyorkan untuk memilih pertukaran dengan yuran yang lebih rendah dan melaraskan selang grid dan nisbah peruntukan dana berdasarkan keadaan pasaran tertentu.

Secara keseluruhan, strategi grid aritmetik sangat sesuai untuk pasaran mata wang kripto yang tidak menentu, tetapi boleh tertakluk kepada risiko yang ketara dalam pasaran unilateral. Dengan menetapkan parameter dengan betul dan mengoptimumkan pengurusan dana, keteguhan dan keuntungan strategi boleh dipertingkatkan dengan berkesan.

Spot: Strategi Grid Dinamik

Strategi Grid DinamikBerbeza daripada strategi grid tetap tradisional, iaPenjanaan DinamikdanMelaraskan Nod MeshStrategi ini membolehkan lebih fleksibiliti dalam turun naik pasaran. Strategi ini menjana nod grid baharu berdasarkan turun naik pasaran masa nyata, meningkatkan kebolehsuaian strategi dan keupayaan kawalan risiko. Konsep teras adalah untuk hanya menjana nod baharu apabila turun naik harga melebihi ambang tertentu dan untuk mengurus kedudukan dengan sewajarnya.

Ciri Teras

1. Penjanaan nod mesh dinamik：

   • Harga pasaran menembusi nod grid sebelumnya dan julat turun naik melebihi julat pratetap (oleh_GridPointDiskawalan), strategi menjana nod grid baharu.
   • Setiap nod grid merekodkan maklumat harga dan kedudukan semasa, dan menetapkan syarat penutupan (oleh_GridCovDisSpread penutupan terkawal).

2. Operasi beli dan jual：

   • Arah yang panjang（direction = 1): Apabila harga naik dan menembusi nod grid, jual aset yang anda pegang; bila dah jatuh, beli lagi.
   • Arah pendek（direction = -1): Apabila harga jatuh dan menembusi nod grid, beli aset; apabila ia melantun, jual aset yang dipegang.

3. Operasi penutupan：

   • Apabila harga mencapai harga penutup yang ditetapkan (_GridCovDisTetapkan), laksanakan operasi beli balik (apabila pergi beli) atau jual (apabila turun) mengikut arah semasa untuk melengkapkan penutupan kedudukan.

4. Kawalan kuantiti jaringan：

   • Jika bilangan nod grid melebihi nilai tetapan maksimum (_GridNum), strategi akan memadamkan nod grid terawal secara automatik, dengan itu menghalang kedudukan yang berlebihan dan mengurangkan risiko.

Logik Teras

1. Parameter permulaan：

   • _GridNum: Bilangan maksimum nod grid, bilangan maksimum nod grid yang dibenarkan oleh strategi kawalan untuk dipegang pada masa yang sama.
   • _GridPointAmount: Kuantiti pesanan setiap nod grid.
   • _GridPointDis: Jarak harga antara nod grid.
   • _GridCovDis: Perbezaan harga untuk menutup kedudukan. Apabila turun naik antara harga pasaran dan harga grid melebihi perbezaan harga ini, kedudukan akan ditutup.

2. Fungsi Kemas KiniGrid：

   • Berdasarkan harga semasa (current_price), harga belian (bids_price) dan harga jualan (asks_price) mengemas kini nod grid. Setiap kali harga pasaran menembusi nod grid, strategi menjana nod grid baharu dan melaksanakan perdagangan yang sepadan.
   • Semak sama ada keadaan penutupan dicetuskan dan laksanakan operasi penutupan apabila dicetuskan.
   • Mengawal bilangan maksimum nod grid. Jika bilangan maksimum melebihi, nod grid tertua akan dipadamkan.

3. Gelung Utama：

   • mainFungsi ini secara berterusan memperoleh data harga pasaran masa nyata dan panggilanUpdateGridFungsi mengemas kini nod grid dan melaksanakan operasi perdagangan.
   • lulusLogStatusRekod status grid semasa, maklumat akaun, dsb. untuk memudahkan pemantauan masa nyata operasi strategi.

Kod strategi (memerlukan tempat Python dan rujukan templat lukisan)

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

Nota:

1. Untuk membantu semua orang memahami proses penjanaan grid, banyak ulasan ditambahkan pada kod, yang boleh dipadamkan dalam aplikasi sebenar.
2. Untuk memudahkan dagangan, strategi spot menggunakan perpustakaan dagangan templat spot. Anda boleh memerhati kod sumber untuk mengetahui tentangnya.
3. Apabila digunakan untuk perdagangan sebenar, ia perlu diperbaiki mengikut ciri-ciri pertukaran yang berbeza.

Niaga Hadapan: Strategi Grid Dwi Arah Panjang-Pendek

Strategi Grid Dwi Arah Panjang-Pendek ialah varian grid yang lebih kompleks tetapi berkuasa yang membolehkan dagangan serentak dalam kedua-dua arah panjang dan pendek, memaksimumkan peluang keuntungan dalam pasaran yang tidak menentu. Pada terasnya, strategi ini melaraskan kedudukan secara dinamik berdasarkan sisihan harga daripada harga awal, mencapai strategi yang benar-benar neutral pasaran.

Ciri Teras

1. Kedua-dua mod panjang dan pendek: Tidak kira sama ada harga naik atau turun, strategi boleh memperoleh keuntungan dengan beroperasi dalam arah yang sepadan
2. Pindaan kedudukan dinamik：Kira kedudukan sasaran berdasarkan nisbah sisihan harga daripada harga awal
3. Tertib grid dua hala: Tetapkan pesanan beli dan jual pada masa yang sama untuk menangkap turun naik harga dalam kedua-dua arah
4. Kawalan Risiko：Mengurangkan risiko unilateral melalui pengurusan kedudukan yang munasabah dan kawalan pesanan

Logik Strategi

Logik teras strategi adalah untuk menentukan kedudukan sasaran berdasarkan tahap sisihan antara harga dan harga awal:

• Apabila harga naik, kedudukan sasaran adalah negatif (pendek), dan semakin banyak harga naik, semakin besar kedudukan jual.
• Apabila harga jatuh, kedudukan sasaran adalah positif (panjang). Semakin banyak harga jatuh, semakin besar kedudukan panjang.
• Laraskan kedudukan sebenar secara beransur-ansur kepada kedudukan sasaran melalui pelaksanaan pesanan grid

Kod Strategi

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秒再继续

Kelebihan strategi grid dua hala jangka panjang adalah kebolehsesuaiannya dengan pelbagai keadaan pasaran, membolehkan pulangan yang menguntungkan melalui operasi yang sesuai, sama ada meningkat, menurun atau tidak menentu. Walau bagaimanapun, ia juga memerlukan pengurusan risiko yang teliti, terutamanya dalam keadaan pasaran yang melampau.

ringkaskan

Fleksibiliti dan automasi strategi grid menjadikannya alat biasa dalam perdagangan kuantitatif. Varian grid yang berbeza boleh menyesuaikan diri dengan pelbagai persekitaran pasaran. Setiap strategi mempunyai senario dan kelebihan aplikasi tersendiri. Pelabur boleh memilih strategi grid yang sesuai berdasarkan turun naik pasaran tertentu dan selera risiko peribadi, dan menggabungkannya dengan alat seperti pengurusan kedudukan dinamik dan strategi henti rugi dan ambil untung untuk mengoptimumkan lagi keberkesanan strategi.

perlukanmenggambarkanTiga strategi yang dibincangkan dalam artikel ini semuanya daripada Strategy Plaza pada platform Inventor, memberikan ringkasan. Sebagai jenis strategi kuantitatif klasik, strategi grid masih menawarkan banyak perkara untuk diterokai, seperti cara mengelakkan panggilan margin dan mengurangkan risiko, dan cara mengoptimumkan penggunaan dana untuk meningkatkan pulangan. Pihak yang berminat boleh melawati Strategy Plaza, di mana strategi grid masa nyata tersedia untuk rujukan dan kajian.