کریپٹو کرنسی مارکیٹ ایک منفرد تجارتی ماحول پیش کرتی ہے، جو گرڈ ٹریڈنگ کی حکمت عملیوں کے لیے ایک مثالی درخواست کا منظر نامہ تیار کرتی ہے۔ روایتی مالیاتی منڈیوں کے مقابلے میں، cryptocurrency کا شعبہ ²⁴⁄₇ کام کرتا ہے، قیمتوں میں مسلسل اور متواتر اتار چڑھاؤ کے ساتھ، گرڈ کی حکمت عملیوں کے لیے ثالثی کے وافر مواقع پیدا کرتا ہے۔ مزید برآں، بڑے تجارتی آلات جیسے کہ اسپاٹ اور پرپیچوئل کنٹریکٹس میں میعاد ختم ہونے کی کوئی پابندی نہیں ہے، جس سے تاجروں کو معاہدے کی میعاد ختم ہونے کے خطرے کی فکر کیے بغیر طویل مدت کے لیے عہدوں پر فائز رہنے کی اجازت ملتی ہے۔ مزید برآں، cryptocurrency مارکیٹ کی زیادہ اتار چڑھاؤ اور نسبتاً زیادہ لیکویڈیٹی گرڈ کی حکمت عملیوں کو نافذ کرنے کے لیے سازگار حالات فراہم کرتی ہے۔

یہ خاص طور پر ان خصوصیات کی وجہ سے ہے کہ گرڈ ٹریڈنگ کی حکمت عملی cryptocurrency مارکیٹ میں مضبوط قابل اطلاق اور منافع کی صلاحیت کو ظاہر کرتی ہے۔ گرڈ ٹریڈنگ کرپٹو کرنسی مارکیٹ میں وسیع پیمانے پر استعمال ہونے والی حکمت عملی ہے جو تاجروں کو مارکیٹ کی سمت کا اندازہ لگائے بغیر مارکیٹ کے اتار چڑھاؤ سے فائدہ اٹھانے کی اجازت دیتی ہے۔ مختلف قیمتوں کی حدود میں خرید و فروخت کے آرڈر دے کر، گرڈ ٹریڈنگ تاجروں کو بڑھتی ہوئی اور گرتی ہوئی قیمتوں کے دوران منافع حاصل کرنے میں مدد کرتی ہے۔

گرڈ ٹریڈنگ کی حکمت عملیوں میں بہت سی تبدیلیاں ہوتی ہیں۔ یہ مضمون صرف چند فارمیٹس پر مختصراً گفتگو کرے گا تاکہ ابتدائی افراد کو اس کلاسک مقداری تجارتی طریقہ کے ساتھ شروع کرنے میں مدد ملے۔ گرڈ ٹریڈنگ کی حکمت عملی کا بنیادی خیال مختلف قیمتوں کی سطحوں پر خرید و فروخت کے آرڈرز کا سلسلہ جاری کرنا ہے۔ خریداری کے آرڈر اس وقت دیئے جاتے ہیں جب قیمت گرڈ کے نچلے نوڈس تک پہنچ جاتی ہے، اور فروخت کے آرڈر اس وقت دیئے جاتے ہیں جب قیمت اوپری نوڈس تک پہنچ جاتی ہے، اس طرح مارکیٹ کے اتار چڑھاو سے تھوڑا منافع کمایا جاتا ہے۔ اس حکمت عملی کا فائدہ یہ ہے کہ تاجروں کو مارکیٹ کی سمت کا اندازہ لگانے کی ضرورت نہیں ہے۔ وہ گرڈ کے اندر مارکیٹ کی قیمت کے اتار چڑھاو پر انحصار کرتے ہیں۔

گرڈ حکمت عملی کے اصول

روایتی گرڈ ٹریڈنگ کے اہم عناصر

• گرڈ نوڈس:پہلے سے طے شدہ قیمت پوائنٹس جن پر آرڈرز خرید و فروخت کیے جاتے ہیں۔
• گرڈ وقفہ کاری:ملحقہ گرڈ نوڈس کے درمیان قیمت کا فاصلہ طے کرتا ہے کہ لین دین کو متحرک کرنے کے لیے قیمت میں کتنے اتار چڑھاؤ کی ضرورت ہے۔
• گرڈ سائز:گرڈ نوڈس کی کل تعداد حکمت عملی میں شامل قیمت کی حد کو کنٹرول کرتی ہے۔

گرڈ ٹریڈنگ کی حکمت عملی کیسے کام کرتی ہے۔

• جب قیمت ایک نچلی سطح سے بڑھتی ہے اور سیٹ گرڈ نوڈ سے ٹوٹ جاتی ہے، تو فروخت کا آرڈر شروع ہوتا ہے۔
• جب قیمت اونچی سطح سے واپس آتی ہے اور سیٹ گرڈ نوڈ سے ٹوٹ جاتی ہے، تو خرید آرڈر شروع ہو جاتا ہے۔
• مختلف رینجز میں مسلسل “کم خریدنا اور زیادہ بیچنا”، یہاں تک کہ اگر قیمت رینج کے اندر آگے پیچھے ہوتی رہتی ہے، تب بھی آپ ہر اتار چڑھاؤ سے منافع کما سکتے ہیں۔

مثال

فرض کریں کہ گرڈ کی حکمت عملی \(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"])

ریاضی کی گرڈ حکمت عملی کرپٹو کرنسی مارکیٹ میں خاص طور پر غیر مستحکم لیکن غیر متوقع مارکیٹوں میں قابل اطلاق ہے۔ مقررہ قیمت کے وقفوں پر خرید و فروخت کے آرڈرز دے کر، یہ حکمت عملی خودکار آپریشنز اور سادہ منطق کو برقرار رکھتے ہوئے مارکیٹ کے اتار چڑھاو کو مؤثر طریقے سے پکڑتی ہے۔ cryptocurrency مارکیٹ کی اعلیٰ اتار چڑھاؤ اس حکمت عملی کو پھلنے پھولنے کا ایک اچھا موقع فراہم کرتا ہے۔

یہ بات قابل غور ہے کہ ریاضی کی گرڈ حکمت عملی کے لین دین کے اخراجات بنیادی طور پر بار بار خرید و فروخت کے آرڈرز کو رکھنے یا منسوخ کرنے کے بجائے آتے ہیں۔ یہ خصوصیت اعلی لین دین کی فیس کے ساتھ کریپٹو کرنسی ایکسچینجز پر خصوصی توجہ کی ضرورت ہے۔ منافع کو بہتر بنانے کے لیے، کم فیس کے ساتھ ایکسچینجز کا انتخاب کرنے اور مخصوص مارکیٹ کے حالات کی بنیاد پر گرڈ وقفہ اور فنڈ مختص تناسب کو ایڈجسٹ کرنے کی سفارش کی جاتی ہے۔

مجموعی طور پر، ریاضی کی گرڈ کی حکمت عملی غیر مستحکم کرپٹو کرنسی مارکیٹ کے لیے اچھی طرح سے موزوں ہے، لیکن یکطرفہ مارکیٹوں میں اہم خطرے سے مشروط ہو سکتی ہے۔ پیرامیٹرز کو صحیح طریقے سے ترتیب دینے اور فنڈ مینجمنٹ کو بہتر بنانے سے، حکمت عملی کی مضبوطی اور منافع کو مؤثر طریقے سے بہتر بنایا جا سکتا ہے۔

اسپاٹ: متحرک گرڈ حکمت عملی

متحرک گرڈ حکمت عملیروایتی فکسڈ گرڈ حکمت عملی سے مختلف، یہمتحرک نسلاورمیش نوڈس کو ایڈجسٹ کرنایہ حکمت عملی مارکیٹ کے اتار چڑھاو میں زیادہ لچک پیدا کرنے کی اجازت دیتی ہے۔ یہ حکمت عملی ریئل ٹائم مارکیٹ کے اتار چڑھاو کی بنیاد پر نئے گرڈ نوڈس تیار کرتی ہے، حکمت عملی کی موافقت اور رسک کنٹرول کی صلاحیتوں کو بہتر بناتی ہے۔ بنیادی تصور صرف نئے نوڈس تیار کرنا ہے جب قیمت میں اتار چڑھاو ایک خاص حد سے تجاوز کر جائے، اور مناسب طریقے سے پوزیشنوں کا انتظام کیا جائے۔

بنیادی خصوصیات

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. رسک کنٹرول：مناسب پوزیشن مینجمنٹ اور آرڈر کنٹرول کے ذریعے یکطرفہ خطرات کو کم کریں۔

حکمت عملی کی منطق

حکمت عملی کی بنیادی منطق قیمت اور ابتدائی قیمت کے درمیان انحراف کی ڈگری کی بنیاد پر ہدف کی پوزیشن کا تعین کرنا ہے:

• جب قیمت بڑھتی ہے، ہدف کی پوزیشن منفی (مختصر) ہوتی ہے، اور جتنی زیادہ قیمت بڑھتی ہے، مختصر پوزیشن اتنی ہی بڑی ہوتی ہے۔
• جب قیمت گرتی ہے تو ہدف کی پوزیشن مثبت (لمبی) ہوتی ہے۔ جتنی زیادہ قیمت گرتی ہے، اتنی ہی بڑی لمبی پوزیشن۔
• گرڈ آرڈرز پر عمل درآمد کے ذریعے دھیرے دھیرے اصل پوزیشن کو ہدف کی پوزیشن میں ایڈجسٹ کریں۔

حکمت عملی کوڈ

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

طویل مختصر دو طرفہ گرڈ حکمت عملی کا فائدہ مختلف مارکیٹ کے حالات کے مطابق اس کی موافقت ہے، جو مناسب آپریشنز کے ذریعے منافع بخش واپسی کی اجازت دیتا ہے، چاہے وہ بڑھتا ہو، گرتا ہو، یا اتار چڑھاؤ۔ تاہم، اس کے لیے خطرے کے محتاط انتظام کی بھی ضرورت ہوتی ہے، خاص طور پر انتہائی مارکیٹ کے حالات میں۔

خلاصہ کریں۔

گرڈ کی حکمت عملیوں کی لچک اور آٹومیشن انہیں مقداری تجارت میں ایک عام ٹول بناتی ہے۔ مختلف گرڈ کی مختلف حالتیں مارکیٹ کے مختلف ماحول میں ڈھل سکتی ہیں۔ ہر حکمت عملی کے اپنے مخصوص اطلاق کے منظرنامے اور فوائد ہوتے ہیں۔ سرمایہ کار مارکیٹ کے مخصوص اتار چڑھاو اور ذاتی خطرے کی بھوک کی بنیاد پر مناسب گرڈ حکمت عملی کا انتخاب کر سکتے ہیں، اور حکمت عملی کی تاثیر کو مزید بہتر بنانے کے لیے اسے متحرک پوزیشن مینجمنٹ اور سٹاپ لاس اور ٹیک-پرافٹ حکمت عملی جیسے ٹولز کے ساتھ جوڑ سکتے ہیں۔

ضرورتمثال دینااس مضمون میں جن تین حکمت عملیوں پر تبادلہ خیال کیا گیا ہے وہ سبھی انوینٹر پلیٹ فارم پر حکمت عملی پلازہ سے ہیں، ایک خلاصہ فراہم کرتے ہیں۔ ایک کلاسک قسم کی مقداری حکمت عملی کے طور پر، گرڈ کی حکمت عملی اب بھی دریافت کرنے کے لیے بہت کچھ پیش کرتی ہے، جیسے کہ مارجن کالز سے کیسے بچا جائے اور خطرے کو کیسے کم کیا جائے، اور منافع کو بڑھانے کے لیے فنڈ کے استعمال کو کیسے بہتر بنایا جائے۔ دلچسپی رکھنے والی جماعتیں سٹریٹیجی پلازہ کا دورہ کر سکتی ہیں، جہاں ریئل ٹائم گرڈ حکمت عملی حوالہ اور مطالعہ کے لیے دستیاب ہے۔