Pasar mata uang kripto menawarkan lingkungan perdagangan yang unik, menciptakan skenario aplikasi yang ideal untuk strategi perdagangan grid. Dibandingkan dengan pasar keuangan tradisional, sektor mata uang kripto beroperasi ²⁴⁄₇, dengan fluktuasi harga yang terus-menerus dan sering, menciptakan peluang arbitrase yang melimpah untuk strategi grid. Lebih lanjut, instrumen perdagangan utama seperti kontrak spot dan perpetual tidak memiliki batasan kedaluwarsa, memungkinkan pedagang untuk memegang posisi jangka panjang tanpa khawatir tentang risiko kedaluwarsa kontrak. Lebih lanjut, volatilitas pasar mata uang kripto yang tinggi dan likuiditas yang relatif tinggi memberikan kondisi yang menguntungkan untuk menerapkan strategi grid.

Berkat karakteristik inilah strategi perdagangan grid menunjukkan penerapan dan potensi keuntungan yang kuat di pasar mata uang kripto. Perdagangan grid adalah strategi yang banyak digunakan di pasar mata uang kripto yang memungkinkan para pedagang mendapatkan keuntungan dari volatilitas pasar tanpa harus memprediksi arah pasar. Dengan menempatkan order beli dan jual pada rentang harga yang berbeda, perdagangan grid membantu para pedagang meraih keuntungan baik saat harga naik maupun turun.

Strategi perdagangan grid memiliki banyak variasi. Artikel ini hanya akan membahas secara singkat beberapa format untuk membantu pemula memulai metode perdagangan kuantitatif klasik ini. Ide inti dari strategi perdagangan grid adalah menempatkan serangkaian order beli dan jual pada tingkat harga yang berbeda. Order beli ditempatkan ketika harga mencapai titik terendah grid, dan order jual ditempatkan ketika harga mencapai titik tertinggi, sehingga menghasilkan keuntungan kecil dari fluktuasi pasar. Keuntungan dari strategi ini adalah trader tidak perlu memprediksi arah pasar; mereka mengandalkan fluktuasi harga pasar di dalam grid.

Prinsip Strategi Grid

Elemen kunci perdagangan grid tradisional

• Simpul Jaringan:Titik harga yang telah ditetapkan di mana pesanan beli atau jual ditempatkan.
• Jarak Grid:Jarak harga antara simpul jaringan yang berdekatan menentukan seberapa besar harga perlu berfluktuasi untuk memicu transaksi.
• Ukuran Kotak:Jumlah total node jaringan mengendalikan kisaran harga yang dicakup oleh strategi.

Cara Kerja Strategi Perdagangan Grid

• Ketika harga naik dari level rendah dan menembus node grid yang ditetapkan, perintah jual dipicu.
• Ketika harga jatuh kembali dari level tinggi dan menembus simpul grid yang ditetapkan, perintah beli dipicu.
• Dengan terus-menerus “membeli pada harga rendah dan menjual pada harga tinggi” dalam rentang yang berbeda, bahkan jika harga berfluktuasi maju mundur dalam rentang tersebut, Anda masih dapat memperoleh keuntungan dari setiap fluktuasi.

Contoh

Misalkan sebuah strategi grid ditetapkan dengan interval grid \(8.000 hingga \)9.000, dengan interval grid \(500. Ketika harga naik dari \)8.000 menjadi \(8.500, strategi tersebut akan membeli pada harga \)8.000 dan menjual pada harga \(8.500. Jika harga naik lebih lanjut ke \)9.000, strategi tersebut akan menjual kembali sebagian asetnya. Ketika harga turun kembali dari \(9.000 menjadi \)8.500, strategi tersebut akan membeli kembali. Dengan mengulangi proses ini, strategi tersebut dapat terus mengumpulkan keuntungan di tengah fluktuasi pasar.

Perbandingan antara Strategi Perdagangan Grid dan Strategi Perdagangan Seimbang

Inti dari strategi yang seimbang adalah mempertahankan rasio aset yang tetap, misalnya 50% mata uang digital dan 50% mata uang fiat. Ketika harga mata uang kripto naik dan proporsi mata uang kripto yang dimiliki melebihi 50%, mata uang kripto tersebut dijual; ketika harganya turun, mata uang kripto tersebut dibeli. Hal ini memastikan bahwa nilai aset yang dimiliki tetap mendekati rasio yang tetap. Terlepas dari fluktuasi pasar, strategi yang seimbang mempertahankan jumlah mata uang kripto tertentu.

Persamaan dan perbedaan antara strategi grid dan strategi keseimbangan

• Persamaan:Keduanya mendapat keuntungan dari volatilitas dengan membeli pada harga rendah dan menjual pada harga tinggi, dan strategi ini dapat merealisasikan nilai ketika pasar kembali ke harga semula.
• Perbedaan:Strategi grid hanya beroperasi dalam rentang harga yang telah ditentukan, sementara strategi seimbang tidak bergantung pada rentang harga tertentu. Strategi grid mungkin tidak dapat melanjutkan perdagangan jika harga jatuh di luar rentang tersebut, sementara strategi seimbang memungkinkan pembelian dan penjualan yang konstan, sehingga likuiditas tetap terjaga.

Kontrak: Strategi Grid Aritmatika

Strategi grid aritmatika adalah strategi perdagangan kuantitatif klasik yang sering digunakan di pasar yang volatil. Strategi ini menangkap keuntungan dari fluktuasi harga dengan menempatkan order beli dan jual pada interval harga tetap (interval aritmatika). Strategi ini cocok untuk pasar dengan volatilitas tinggi tetapi arahnya tidak dapat diprediksi, seperti mata uang kripto dan kontrak berjangka tertentu.

Logika Inti

Konsep inti:

1. interval jarak yang sama
   Dalam strategi grid aritmatika, ada selisih antara harga beli dan harga jual.Interval harga tetap, yang ada di dalam kodegridMisalnya, ketika harga berfluktuasi sebesar 300 unit (seperti pada kodegrid=300), perintah beli atau jual dipicu.

2. Inisialisasi grid
   Strategi ini menghasilkan harga beli dan jual awal berdasarkan harga saat ini, yaitubuyp Dan sellpDua interval harga didasarkan pada interval gridgridUntuk mengatur, masing-masing di atas dan di bawah harga saat inigridsatuan.

3. Ambil untung dan balikkan
   Ketika harga naik ke kisaran tertentu, strategi akan membeli di area posisi long dan menetapkan order jual untuk mengambil keuntungan. Jika harga terus naik ke area posisi reverse (upper), posisi panjang akan mengambil keuntungan dan melakukan short, dan sebaliknya.

4. Manajemen posisi dalam grid
   Setiap tindakan beli atau jual dalam grid akan dipicu ketika harga mencapai harga yang telah ditetapkanbuyp atau sellpSetelah setiap transaksi, sistem secara otomatis menyesuaikan kelompok harga beli dan jual berikutnya untuk mempertahankan interval grid tetap.

5. Menambah dan mengurangi posisi
   Strategi ini terus menyesuaikan posisinya berdasarkan harga grid. Ketika harga mencapai titik beli, ia meningkatkan posisinya (meningkatkan posisinya); ketika harga mencapai titik jual, ia secara bertahap mengurangi posisinya (menurunkan posisinya). Dengan membeli dan menjual secara berulang, strategi ini menangkap setiap fluktuasi pasar yang kecil.

Kode 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 aritmatika memiliki penerapan yang cukup luas di pasar mata uang kripto, terutama di pasar yang volatil namun tidak dapat diprediksi. Dengan menempatkan order beli dan jual pada interval harga tetap, strategi ini secara efektif menangkap fluktuasi pasar sambil mempertahankan operasi otomatis dan logika sederhana. Volatilitas pasar mata uang kripto yang tinggi memberikan peluang bagus bagi strategi ini untuk berkembang pesat.

Perlu dicatat bahwa biaya transaksi strategi grid aritmatika terutama berasal dari seringnya order beli dan jual, alih-alih menempatkan atau membatalkannya. Karakteristik ini memerlukan perhatian khusus pada bursa mata uang kripto dengan biaya transaksi yang tinggi. Untuk mengoptimalkan imbal hasil, disarankan untuk memilih bursa dengan biaya lebih rendah dan menyesuaikan interval grid serta rasio alokasi dana berdasarkan kondisi pasar tertentu.

Secara keseluruhan, strategi grid aritmatika sangat cocok untuk pasar mata uang kripto yang volatil, tetapi dapat menimbulkan risiko yang signifikan di pasar unilateral. Dengan menetapkan parameter yang tepat dan mengoptimalkan pengelolaan dana, ketahanan dan profitabilitas strategi dapat ditingkatkan secara efektif.

Spot: Strategi Grid Dinamis

Strategi Jaringan DinamisBerbeda dengan strategi jaringan tetap tradisional,Generasi DinamisDanMenyesuaikan Node MeshStrategi ini memungkinkan fleksibilitas yang lebih besar dalam menghadapi fluktuasi pasar. Strategi ini menghasilkan node grid baru berdasarkan fluktuasi pasar secara real-time, sehingga meningkatkan kemampuan adaptasi dan pengendalian risiko strategi. Konsep intinya adalah hanya menghasilkan node baru ketika fluktuasi harga melebihi ambang batas tertentu, dan mengelola posisi dengan tepat.

Fitur Inti

1. Pembuatan simpul mesh dinamis：

   • Harga pasar menembus node grid sebelumnya dan rentang fluktuasi melebihi rentang yang telah ditetapkan (dengan_GridPointDiskontrol), strategi tersebut menghasilkan simpul jaringan baru.
   • Setiap node grid mencatat informasi harga dan posisi saat ini, dan menetapkan kondisi penutupan (dengan_GridCovDisPenyebaran penutupan terkendali).

2. Operasi beli dan jual：

   • Arah panjang（direction = 1): Ketika harga naik dan menembus simpul grid, jual aset yang Anda miliki; ketika harga turun, beli lagi.
   • Arah pendek（direction = -1): Ketika harga turun dan menembus simpul grid, beli aset tersebut; ketika harga pulih, jual aset yang ditahan.

3. Operasi penutupan：

   • Ketika harga mencapai harga penutupan yang ditetapkan (_GridCovDisTetapkan), jalankan operasi beli kembali (ketika akan membeli) atau jual (ketika akan menjual) sesuai dengan arah saat ini untuk menyelesaikan penutupan posisi.

4. Kontrol kuantitas mesh：

   • Jika jumlah node grid melebihi nilai pengaturan maksimum (_GridNum), strategi ini akan secara otomatis menghapus node grid paling awal, sehingga mencegah posisi berlebihan dan mengurangi risiko.

Logika Inti

1. Parameter inisialisasi：

   • _GridNum: Jumlah maksimum simpul grid, jumlah maksimum simpul grid yang dapat ditampung oleh strategi kontrol pada waktu yang sama.
   • _GridPointAmount: Jumlah pesanan setiap simpul jaringan.
   • _GridPointDis:Jarak harga antara simpul grid.
   • _GridCovDisSelisih harga untuk menutup posisi. Ketika fluktuasi antara harga pasar dan harga grid melebihi selisih harga ini, posisi akan ditutup.

2. Fungsi UpdateGrid：

   • Berdasarkan harga saat ini (current_price), harga pembelian (bids_price) dan harga jual (asks_price) memperbarui node grid. Setiap kali harga pasar menembus node grid, strategi akan menghasilkan node grid baru dan mengeksekusi perdagangan terkait.
   • Periksa apakah kondisi penutupan dipicu dan jalankan operasi penutupan saat dipicu.
   • Mengontrol jumlah maksimum simpul grid. Jika jumlah maksimum terlampaui, simpul grid terlama akan dihapus.

3. Lingkaran Utama：

   • mainFungsi ini terus menerus memperoleh data harga pasar secara real-time dan panggilanUpdateGridFungsi memperbarui simpul jaringan dan melakukan operasi perdagangan.
   • lulusLogStatusCatat status jaringan saat ini, informasi akun, dll. untuk memfasilitasi pemantauan operasi strategi secara real-time.

Kode strategi (memerlukan referensi titik Python dan templat gambar)

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

Catatan:

1. Untuk membantu semua orang memahami proses pembuatan grid, banyak komentar ditambahkan ke kode, yang dapat dihapus dalam aplikasi sebenarnya.
2. Untuk memfasilitasi perdagangan, strategi spot menggunakan pustaka perdagangan templat spot. Anda dapat melihat kode sumbernya untuk mempelajarinya.
3. Ketika diterapkan pada perdagangan nyata, hal itu perlu ditingkatkan sesuai dengan karakteristik bursa yang berbeda-beda.

Futures: Strategi Grid Dua Arah Jangka Panjang-Pendek

Strategi Grid Dua Arah Long-Short adalah varian grid yang lebih kompleks namun kuat yang memungkinkan perdagangan simultan dalam arah long dan short, memaksimalkan peluang keuntungan di pasar yang volatil. Intinya, strategi ini menyesuaikan posisi secara dinamis berdasarkan deviasi harga dari harga awal, sehingga mencapai strategi yang benar-benar netral terhadap pasar.

Fitur Inti

1. Mode panjang dan pendek:Terlepas dari apakah harga naik atau turun, strategi dapat memperoleh keuntungan dengan beroperasi pada arah yang sesuai
2. Perubahan posisi dinamis：Hitung posisi target berdasarkan deviasi harga dari harga awal
3. Urutan grid dua arah: Tetapkan pesanan beli dan jual pada saat yang sama untuk menangkap fluktuasi harga di kedua arah
4. Pengendalian Risiko：Mengurangi risiko unilateral melalui manajemen posisi dan pengendalian pesanan yang wajar

Logika Strategi

Logika inti dari strategi ini adalah menentukan posisi target berdasarkan tingkat deviasi antara harga dan harga awal:

• Ketika harga naik, posisi targetnya negatif (short), dan semakin tinggi harga naik, semakin besar posisi short.
• Ketika harga turun, posisi target positif (long). Semakin rendah harga, semakin besar posisi long.
• Sesuaikan posisi aktual secara bertahap ke posisi target melalui pelaksanaan perintah grid

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

Keunggulan strategi grid dua arah jangka pendek-panjang adalah kemampuannya beradaptasi terhadap berbagai kondisi pasar, yang memungkinkan imbal hasil yang menguntungkan melalui operasi yang tepat, baik saat naik, turun, maupun bergejolak. Namun, strategi ini juga membutuhkan manajemen risiko yang cermat, terutama dalam kondisi pasar yang ekstrem.

Meringkaskan

Fleksibilitas dan otomatisasi strategi grid menjadikannya alat umum dalam perdagangan kuantitatif. Berbagai varian grid dapat beradaptasi dengan berbagai lingkungan pasar. Setiap strategi memiliki skenario penerapan dan keunggulannya masing-masing. Investor dapat memilih strategi grid yang tepat berdasarkan fluktuasi pasar dan selera risiko pribadi, lalu menggabungkannya dengan berbagai alat seperti manajemen posisi dinamis serta strategi stop-loss dan take-profit untuk lebih mengoptimalkan efektivitas strategi.

membutuhkanmenjelaskanKetiga strategi yang dibahas dalam artikel ini semuanya berasal dari Strategy Plaza di platform Inventor, yang memberikan ringkasan. Sebagai jenis strategi kuantitatif klasik, strategi grid masih menawarkan banyak hal untuk dieksplorasi, seperti cara menghindari margin call dan memitigasi risiko, serta cara mengoptimalkan pemanfaatan dana untuk meningkatkan imbal hasil. Bagi yang berminat, silakan kunjungi Strategy Plaza, tempat strategi grid real-time tersedia untuk referensi dan pembelajaran.