क्रिप्टोकरेंसी बाज़ार एक अनूठा व्यापारिक वातावरण प्रदान करता है, जो ग्रिड ट्रेडिंग रणनीतियों के लिए एक आदर्श अनुप्रयोग परिदृश्य बनाता है। पारंपरिक वित्तीय बाज़ारों की तुलना में, क्रिप्टोकरेंसी क्षेत्र ²⁴⁄₇ संचालित होता है, जिसमें निरंतर और लगातार मूल्य उतार-चढ़ाव होता रहता है, जिससे ग्रिड रणनीतियों के लिए प्रचुर आर्बिट्रेज अवसर पैदा होते हैं। इसके अलावा, स्पॉट और पर्पेचुअल कॉन्ट्रैक्ट जैसे प्रमुख व्यापारिक उपकरणों पर कोई समाप्ति प्रतिबंध नहीं है, जिससे व्यापारी अनुबंध समाप्ति जोखिम की चिंता किए बिना लंबी अवधि के लिए अपनी पोजीशन बनाए रख सकते हैं। इसके अलावा, क्रिप्टोकरेंसी बाज़ार की उच्च अस्थिरता और अपेक्षाकृत उच्च तरलता ग्रिड रणनीतियों को लागू करने के लिए अनुकूल परिस्थितियाँ प्रदान करती है।

इन्हीं विशेषताओं के कारण, ग्रिड ट्रेडिंग रणनीतियाँ क्रिप्टोकरेंसी बाज़ार में मज़बूत प्रयोज्यता और लाभ की संभावना प्रदर्शित करती हैं। ग्रिड ट्रेडिंग क्रिप्टोकरेंसी बाज़ार में एक व्यापक रूप से इस्तेमाल की जाने वाली रणनीति है जो व्यापारियों को बाज़ार की दिशा का अनुमान लगाए बिना बाज़ार की अस्थिरता से लाभ कमाने की अनुमति देती है। विभिन्न मूल्य श्रेणियों पर खरीद और बिक्री के ऑर्डर देकर, ग्रिड ट्रेडिंग व्यापारियों को बढ़ती और गिरती कीमतों, दोनों के दौरान लाभ कमाने में मदद करती है।

ग्रिड ट्रेडिंग रणनीतियों के कई रूप हैं। यह लेख शुरुआती लोगों को इस पारंपरिक मात्रात्मक ट्रेडिंग पद्धति से शुरुआत करने में मदद करने के लिए केवल कुछ प्रारूपों पर संक्षेप में चर्चा करेगा। ग्रिड ट्रेडिंग रणनीति का मूल विचार विभिन्न मूल्य स्तरों पर खरीद और बिक्री के आदेशों की एक श्रृंखला रखना है। खरीद के आदेश तब दिए जाते हैं जब कीमत ग्रिड के निचले नोड्स पर पहुँचती है, और बिक्री के आदेश तब दिए जाते हैं जब कीमत ऊपरी नोड्स पर पहुँचती है, जिससे बाजार के उतार-चढ़ाव से थोड़ा लाभ कमाया जा सकता है। इस रणनीति का लाभ यह है कि व्यापारियों को बाजार की दिशा का अनुमान लगाने की आवश्यकता नहीं होती; वे ग्रिड के भीतर बाजार मूल्य के उतार-चढ़ाव पर निर्भर रहते हैं।

ग्रिड रणनीति सिद्धांत

पारंपरिक ग्रिड ट्रेडिंग के प्रमुख तत्व

• ग्रिड नोड्स:पूर्व निर्धारित मूल्य बिंदु जिस पर खरीद या बिक्री के आदेश दिए जाते हैं।
• ग्रिड रिक्ति:आसन्न ग्रिड नोड्स के बीच मूल्य दूरी यह निर्धारित करती है कि लेनदेन को ट्रिगर करने के लिए मूल्य में कितना उतार-चढ़ाव होना चाहिए।
• ग्रिड आकार:ग्रिड नोड्स की कुल संख्या रणनीति द्वारा कवर की गई मूल्य सीमा को नियंत्रित करती है।

ग्रिड ट्रेडिंग रणनीतियाँ कैसे काम करती हैं

• जब कीमत निम्न स्तर से बढ़ती है और निर्धारित ग्रिड नोड को तोड़ती है, तो विक्रय आदेश सक्रिय हो जाता है।
• जब कीमत उच्च स्तर से गिरती है और निर्धारित ग्रिड नोड को तोड़ती है, तो खरीद आदेश सक्रिय हो जाता है।
• विभिन्न श्रेणियों में लगातार “कम कीमत पर खरीद और अधिक कीमत पर बिक्री” करके, भले ही कीमत सीमा के भीतर आगे-पीछे होती रहे, फिर भी आप प्रत्येक उतार-चढ़ाव से लाभ कमा सकते हैं।

उदाहरण

मान लीजिए कि एक ग्रिड रणनीति \(8,000 से \)9,000 के ग्रिड अंतराल और \(500 के ग्रिड अंतराल पर सेट की गई है। जब कीमत \)8,000 से बढ़कर \(8,500 हो जाती है, तो रणनीति \)8,000 पर खरीदेगी और \(8,500 पर बेचेगी। अगर कीमत और बढ़कर \)9,000 हो जाती है, तो यह अपनी कुछ होल्डिंग्स फिर से बेच देगी। जब कीमत \(9,000 से गिरकर \)8,500 हो जाती है, तो यह फिर से खरीदेगी। इस प्रक्रिया को दोहराकर, यह रणनीति बाज़ार में उतार-चढ़ाव के बीच लगातार मुनाफ़ा कमा सकती है।

ग्रिड ट्रेडिंग रणनीति और संतुलित ट्रेडिंग रणनीति के बीच तुलना

एक संतुलित रणनीति का मूल, परिसंपत्तियों का एक निश्चित अनुपात बनाए रखना है, जैसे कि 50% डिजिटल मुद्रा और 50% फ़िएट मुद्रा। जब किसी क्रिप्टोकरेंसी की कीमत बढ़ती है और धारित क्रिप्टोकरेंसी का अनुपात 50% से अधिक हो जाता है, तो उसे बेच दिया जाता है; जब कीमत गिरती है, तो उसे खरीद लिया जाता है। इससे यह सुनिश्चित होता है कि धारित परिसंपत्तियों का मूल्य निश्चित अनुपात के करीब बना रहे। बाज़ार में उतार-चढ़ाव के बावजूद, एक संतुलित रणनीति क्रिप्टोकरेंसी की एक निश्चित मात्रा बनाए रखती है।

ग्रिड रणनीति और संतुलन रणनीति के बीच समानताएं और अंतर

• समानताएँ:दोनों ही कम कीमत पर खरीद कर और अधिक कीमत पर बेच कर अस्थिरता से लाभ कमाते हैं, तथा जब बाजार अपने मूल मूल्य पर वापस आ जाता है, तो इस रणनीति से मूल्य प्राप्त किया जा सकता है।
• मतभेद:ग्रिड रणनीतियाँ केवल एक पूर्व-निर्धारित मूल्य सीमा के भीतर ही काम करती हैं, जबकि संतुलित रणनीतियाँ विशिष्ट मूल्य सीमाओं से स्वतंत्र होती हैं। यदि मूल्य सीमा से बाहर चला जाता है, तो ग्रिड रणनीति व्यापार जारी रखने में असमर्थ हो सकती है, जबकि संतुलित रणनीति तरलता बनाए रखते हुए निरंतर खरीद और बिक्री की अनुमति देती है।

अनुबंध: अंकगणितीय ग्रिड रणनीति

अंकगणितीय ग्रिड रणनीति एक क्लासिक मात्रात्मक ट्रेडिंग रणनीति है जिसका इस्तेमाल अक्सर अस्थिर बाज़ारों में किया जाता है। यह रणनीति निश्चित मूल्य अंतरालों (अंकगणितीय अंतरालों) पर खरीद और बिक्री के ऑर्डर देकर मूल्य में उतार-चढ़ाव से होने वाले लाभ को प्राप्त करती है। यह उच्च अस्थिरता वाले लेकिन अप्रत्याशित दिशा वाले बाज़ारों, जैसे क्रिप्टोकरेंसी और कुछ वायदा अनुबंधों के लिए उपयुक्त है।

कोर लॉजिक

मुख्य अवधारणाएँ:

1. समदूरस्थ अंतराल
   अंकगणितीय ग्रिड रणनीति में खरीद और बिक्री मूल्यों के बीच अंतर होता है।निश्चित मूल्य अंतराल, जो कोड में हैgridउदाहरण के लिए, जब कीमत में 300 इकाइयों का उतार-चढ़ाव होता है (जैसा कि कोड में है)grid=300), तो खरीद या बिक्री का आदेश शुरू हो जाता है।

2. ग्रिड आरंभीकरण
   यह रणनीति वर्तमान मूल्य के आधार पर प्रारंभिक खरीद और बिक्री मूल्य उत्पन्न करती है, जो इस प्रकार हैं:buyp और sellpदो मूल्य अंतराल ग्रिड अंतराल पर आधारित हैंgridवर्तमान मूल्य से क्रमशः ऊपर और नीचे सेट करने के लिएgridइकाइयाँ.

3. लाभ लें और उलट दें
   जब कीमत एक निश्चित सीमा तक बढ़ जाती है, तो रणनीति लॉन्ग पोजीशन क्षेत्र में खरीदारी करेगी और लाभ कमाने के लिए विक्रय आदेश निर्धारित करेगी। यदि कीमत रिवर्स पोजीशन क्षेत्र तक बढ़ना जारी रखती है (upper), तो लंबी स्थिति लाभ लेगी और छोटी हो जाएगी, और इसके विपरीत।

4. ग्रिड के भीतर स्थिति प्रबंधन
   ग्रिड के भीतर प्रत्येक खरीद या बिक्री कार्रवाई तब शुरू होगी जब कीमत पूर्व निर्धारित मूल्य तक पहुंच जाएगीbuyp या sellpप्रत्येक लेनदेन के बाद, सिस्टम एक निश्चित ग्रिड अंतराल बनाए रखने के लिए खरीद और बिक्री मूल्यों के अगले समूह को स्वचालित रूप से समायोजित करता है।

5. पदों को जोड़ना और घटाना
   यह रणनीति ग्रिड मूल्य के आधार पर अपनी स्थिति को लगातार समायोजित करती है। जब मूल्य खरीद बिंदु पर पहुँचता है, तो यह अपनी स्थिति बढ़ा देता है (अपनी स्थिति बढ़ाता है); जब मूल्य बिक्री बिंदु पर पहुँचता है, तो यह धीरे-धीरे अपनी स्थिति कम कर देता है (अपनी स्थिति घटाता है)। बार-बार खरीद-बिक्री करके, यह बाज़ार के हर छोटे-मोटे उतार-चढ़ाव को पकड़ लेता है।

रणनीति कोड

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

क्रिप्टोकरेंसी बाज़ार में, विशेष रूप से अस्थिर लेकिन अप्रत्याशित बाज़ारों में, अंकगणितीय ग्रिड रणनीति की काफ़ी उपयोगिता है। निश्चित मूल्य अंतराल पर खरीद और बिक्री के ऑर्डर देकर, यह रणनीति स्वचालित संचालन और सरल तर्क को बनाए रखते हुए बाज़ार के उतार-चढ़ाव को प्रभावी ढंग से पकड़ लेती है। क्रिप्टोकरेंसी बाज़ार की उच्च अस्थिरता इस रणनीति को फलने-फूलने का एक अच्छा अवसर प्रदान करती है।

यह ध्यान देने योग्य है कि अंकगणितीय ग्रिड रणनीति की लेन-देन लागत मुख्य रूप से बार-बार खरीद-बिक्री के ऑर्डर देने या रद्द करने से आती है। उच्च लेन-देन शुल्क वाले क्रिप्टोकरेंसी एक्सचेंजों पर इस विशेषता पर विशेष ध्यान देने की आवश्यकता है। बेहतर रिटर्न के लिए, कम शुल्क वाले एक्सचेंज चुनने और विशिष्ट बाज़ार स्थितियों के आधार पर ग्रिड अंतराल और फंड आवंटन अनुपात को समायोजित करने की सलाह दी जाती है।

कुल मिलाकर, अंकगणितीय ग्रिड रणनीति अस्थिर क्रिप्टोकरेंसी बाज़ार के लिए उपयुक्त है, लेकिन एकतरफ़ा बाज़ारों में यह काफ़ी जोखिम भरा हो सकता है। मापदंडों को सही ढंग से निर्धारित करके और फंड प्रबंधन को अनुकूलित करके, इस रणनीति की मज़बूती और लाभप्रदता को प्रभावी ढंग से बेहतर बनाया जा सकता है।

स्पॉट: डायनेमिक ग्रिड रणनीति

गतिशील ग्रिड रणनीतिपारंपरिक निश्चित ग्रिड रणनीति से अलग, यहगतिशील पीढ़ीऔरमेष नोड्स को समायोजित करनायह रणनीति बाज़ार के उतार-चढ़ाव में ज़्यादा लचीलापन प्रदान करती है। यह रणनीति वास्तविक समय के बाज़ार उतार-चढ़ाव के आधार पर नए ग्रिड नोड्स उत्पन्न करती है, जिससे रणनीति की अनुकूलन क्षमता और जोखिम नियंत्रण क्षमताएँ बेहतर होती हैं। इसकी मूल अवधारणा यह है कि नए नोड्स केवल तभी उत्पन्न किए जाएँ जब मूल्य में उतार-चढ़ाव एक निश्चित सीमा से अधिक हो, और पोजीशन का उचित प्रबंधन किया जाए।

मुख्य विशेषताएं

1. गतिशील जाल नोड पीढ़ी：

   • बाजार मूल्य पिछले ग्रिड नोड को तोड़ देता है और उतार-चढ़ाव की सीमा पूर्व निर्धारित सीमा से अधिक हो जाती है (_GridPointDisनियंत्रण), रणनीति नए ग्रिड नोड्स उत्पन्न करती है।
   • प्रत्येक ग्रिड नोड वर्तमान मूल्य और स्थिति की जानकारी रिकॉर्ड करता है, और समापन शर्तें निर्धारित करता है (द्वारा)_GridCovDisनियंत्रित समापन प्रसार)।

2. खरीद और बिक्री संचालन：

   • लंबी दिशा（direction = 1): जब कीमत बढ़ जाती है और ग्रिड नोड से टूट जाती है, तो आपके पास मौजूद परिसंपत्तियों को बेच दें; जब यह वापस गिरती है, तो फिर से खरीद लें।
   • लघु निर्देश（direction = -1): जब कीमत गिरती है और ग्रिड नोड से टूट जाती है, तो परिसंपत्ति खरीदें; जब यह पलटती है, तो रखी गई परिसंपत्ति बेच दें।

3. समापन ऑपरेशन：

   • जब कीमत निर्धारित समापन मूल्य पर पहुँच जाती है (_GridCovDisसेट), स्थिति समापन को पूरा करने के लिए वर्तमान दिशा के अनुसार बायबैक (जब लॉन्ग जा रहे हों) या सेल (जब शॉर्ट जा रहे हों) संचालन निष्पादित करें।

4. जाल मात्रा नियंत्रण：

   • यदि ग्रिड नोड्स की संख्या अधिकतम सेटिंग मान से अधिक हो जाती है (_GridNum), रणनीति स्वचालित रूप से सबसे प्रारंभिक ग्रिड नोड को हटा देगी, जिससे अत्यधिक स्थितियों को रोका जा सकेगा और जोखिम कम हो जाएगा।

कोर लॉजिक

1. आरंभीकरण पैरामीटर：

   • _GridNum: ग्रिड नोड्स की अधिकतम संख्या, ग्रिड नोड्स की अधिकतम संख्या जिसे नियंत्रण रणनीति एक ही समय में रखने की अनुमति देती है।
   • _GridPointAmount: प्रत्येक ग्रिड नोड की ऑर्डर मात्रा.
   • _GridPointDis: ग्रिड नोड्स के बीच मूल्य अंतराल.
   • _GridCovDis: किसी स्थिति को बंद करने के लिए मूल्य अंतर। जब बाजार मूल्य और ग्रिड मूल्य के बीच उतार-चढ़ाव इस मूल्य अंतर से अधिक हो जाता है, तो स्थिति बंद कर दी जाएगी।

2. अपडेटग्रिड फ़ंक्शन：

   • वर्तमान मूल्य के आधार पर (current_price), खरीद मूल्य (bids_price) और विक्रय मूल्य (asks_price) ग्रिड नोड्स को अपडेट करता है। जब भी बाज़ार मूल्य किसी ग्रिड नोड से आगे निकलता है, तो रणनीति एक नया ग्रिड नोड उत्पन्न करती है और संबंधित ट्रेड को निष्पादित करती है।
   • जाँच करें कि क्या समापन स्थितियाँ ट्रिगर हुई हैं और ट्रिगर होने पर समापन ऑपरेशन निष्पादित करें।
   • ग्रिड नोड्स की अधिकतम संख्या नियंत्रित करता है। यदि अधिकतम संख्या पार हो जाती है, तो सबसे पुराने ग्रिड नोड्स हटा दिए जाएँगे।

3. मुख्य घेरा：

   • mainयह फ़ंक्शन लगातार वास्तविक समय बाजार मूल्य डेटा प्राप्त करता है और कॉल करता हैUpdateGridफ़ंक्शन ग्रिड नोड्स को अपडेट करते हैं और ट्रेडिंग ऑपरेशन करते हैं।
   • उत्तीर्णLogStatusरणनीति संचालन की वास्तविक समय निगरानी की सुविधा के लिए वर्तमान ग्रिड स्थिति, खाता जानकारी आदि रिकॉर्ड करें।

रणनीति कोड (पाइथन स्पॉट और ड्राइंग टेम्पलेट संदर्भों की आवश्यकता है)

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

ध्यान देंः

1. ग्रिड निर्माण प्रक्रिया को सभी को समझने में मदद करने के लिए, कोड में कई टिप्पणियाँ जोड़ी गई हैं, जिन्हें वास्तविक अनुप्रयोग में हटाया जा सकता है।
2. ट्रेडिंग को आसान बनाने के लिए, स्पॉट रणनीति स्पॉट टेम्प्लेट ट्रेडिंग लाइब्रेरी का उपयोग करती है। इसके बारे में जानने के लिए आप सोर्स कोड देख सकते हैं।
3. जब इसे वास्तविक व्यापार में लागू किया जाता है, तो इसे विभिन्न एक्सचेंजों की विशेषताओं के अनुसार सुधारने की आवश्यकता होती है।

वायदा: दीर्घ-लघु द्विदिशात्मक ग्रिड रणनीति

लॉन्ग-शॉर्ट द्विदिशात्मक ग्रिड रणनीति एक अधिक जटिल लेकिन शक्तिशाली ग्रिड संस्करण है जो लॉन्ग और शॉर्ट, दोनों दिशाओं में एक साथ ट्रेडिंग की अनुमति देता है, जिससे अस्थिर बाजारों में लाभ के अवसरों को अधिकतम किया जा सकता है। मूलतः, यह रणनीति प्रारंभिक मूल्य से मूल्य विचलन के आधार पर पोजीशन को गतिशील रूप से समायोजित करती है, जिससे एक वास्तविक बाजार-तटस्थ रणनीति प्राप्त होती है।

मुख्य विशेषताएं

1. लंबे और छोटे दोनों मोड: चाहे कीमत बढ़े या गिरे, रणनीति संगत दिशा में काम करके लाभ प्राप्त कर सकती है
2. गतिशील स्थिति समायोजनप्रारंभिक मूल्य से मूल्य विचलन के अनुपात के आधार पर लक्ष्य स्थिति की गणना करें
3. दो-तरफ़ा ग्रिड क्रम: दोनों दिशाओं में मूल्य में उतार-चढ़ाव को पकड़ने के लिए एक ही समय में खरीद और बिक्री के आदेश सेट करें
4. जोखिम नियंत्रण：उचित स्थिति प्रबंधन और आदेश नियंत्रण के माध्यम से एकतरफा जोखिम को कम करना

रणनीति तर्क

रणनीति का मुख्य तर्क मूल्य और प्रारंभिक मूल्य के बीच विचलन की डिग्री के आधार पर लक्ष्य स्थिति निर्धारित करना है:

• जब कीमत बढ़ती है, तो लक्ष्य स्थिति नकारात्मक (शॉर्ट) होती है, और जितनी अधिक कीमत बढ़ती है, शॉर्ट स्थिति उतनी ही बड़ी होती है।
• जब कीमत गिरती है, तो लक्ष्य स्थिति सकारात्मक (लॉन्ग) होती है। कीमत जितनी ज़्यादा गिरती है, लॉन्ग स्थिति उतनी ही बड़ी होती है।
• ग्रिड आदेशों के निष्पादन के माध्यम से वास्तविक स्थिति को धीरे-धीरे लक्ष्य स्थिति में समायोजित करें

रणनीति कोड

”`python 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))