परिचय:

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

इस ढांचे में निम्नलिखित विशेषताएं हैं:

• पायथन भाषा पर आधारित, समझने और विस्तार करने में आसान
• बहु-मुद्रा समवर्ती लेनदेन का समर्थन करें
• सुरक्षा परीक्षण के लिए Binance सिम्युलेटेड एक्सचेंज का उपयोग करना
• संपूर्ण कोड उदाहरण और विस्तृत टिप्पणियाँ प्रदान करता है

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

आरंभीकरण रणनीति

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

import time
import json 

SYMBOLS = 'LINK,ETH,TRB'
QUOTO = 'USDT'
INTERVAL = 5

# 全局变量，储存数据
# SYMBOLS代表要交易的币种，格式如"BTC,ETH,LTC"
# QUOTO为基础货币，永续合约常见的有USDT，USDC
# INTERVAL代表循环的间隔
Info = {
    'trade_symbols': SYMBOLS.split(','),  # 交易币种
    'base_coin': QUOTO,                   # 基础货币
    'ticker': {},                         # 行情数据
    'order': {},                          # 订单信息
    'account': {},                        # 账户信息
    'precision': {},                      # 精度信息
    'position': {},                       # 仓位信息
    'time': {},                           # 时间相关数据
    'count': {},                          # 计数器
    'interval': INTERVAL                  # 循环的间隔时间
}

# 初始化策略
def InitInfo():

    # 初始化账户信息，初始余额为0
    Info['account'] = {
        'init_balance': 0,  # 初始余额
        'wallet_balance': 0,  # 钱包余额
        'margin_balance': 0,  # 保证金余额
        'margin_used': 0,  # 已用保证金
        'margin_free': 0,  # 可用保证金
        'profit': 0,  # 总收益
        'profit_rate': 0,  # 收益率
        'unrealised_profit': 0,  # 未实现收益
    }

    # 初始化时间数据，控制更新的时间
    Info['time'] = {
        'update_ticker_time': 0,    # 更新行情的时间
        'update_pos_time': 0,       # 更新仓位的时间
        'update_profit_time': 0,    # 更新利润的时间
        'update_account_time': 0,   # 更新账户信息的时间
        'update_status_time': 0,    # 更新状态的时间
        'last_loop_time': 0,        # 上一次主循环的时间
        'loop_delay': 0,             # 循环延迟
        'start_time': time.time()
    }

    # 初始化每个交易币种的数据
    for symbol in Info['trade_symbols']:
        Info['ticker'][symbol] = {'last': 0, 'ask': 0, 'bid': 0}  # 行情
        Info['order'][symbol] = {                                 # 订单信息
            'buy': {'id': 0, 'price': 0, 'amount': 0},
            'sell': {'id': 0, 'price': 0, 'amount': 0}
        }
        Info['position'][symbol] = {                              # 仓位信息
            'amount': 0, 'hold_price': 0, 'unrealised_profit': 0, 'open_time': 0, 'value': 0
        }
        Info['precision'][symbol] = {}  # 精度信息初始化为空
        Info['position'][symbol] = {                              # 仓位信息
            'amount': 0, 'hold_price': 0, 'unrealised_profit': 0, 'open_time': 0, 'value': 0
        }

बाज़ार की जानकारी प्राप्त करें और सटीकता निर्धारित करें

यह चरण यह सुनिश्चित करता है कि हमारे द्वारा संसाधित की जाने वाली मुद्राओं की कीमतों, मात्राओं और अन्य पहलुओं की सटीकता, साथ ही ऑर्डर की मात्रा, एक्सचेंज के मानकों के अनुरूप हो। विभिन्न व्यापारिक युग्मों (जैसे BTC/USD या ETH/USDT) की कीमतों और मात्राओं के लिए अलग-अलग न्यूनतम सटीकता आवश्यकताएँ होती हैं, इसलिए गैर-अनुपालन वाले ऑर्डर से बचने के लिए हमें एक्सचेंज के API से यह सटीकता जानकारी प्राप्त करनी होगी। उदाहरण के लिए, ETH/USDT दो दशमलव स्थानों की अनुमति दे सकता है, जबकि BTC/USDT आठ दशमलव स्थानों की अनुमति दे सकता है।

उद्देश्य:

• ऑर्डर डेटा की सटीकता सुनिश्चित करने के लिए प्रत्येक मुद्रा के लिए मूल्य और मात्रा की सटीकता प्राप्त करें।
• परिशुद्धता त्रुटियों के कारण ऑर्डर विफलताओं को रोकें।

# 获取精度信息
def GetPrecision():
    # 获取交易所的市场信息
    for presym in Info['trade_symbols']:
        curcontract = presym + '_USDT.swap'
        exchange.GetTicker(curcontract)
    exchange_info = exchange.GetMarkets()
    
    # 遍历市场中的所有交易对
    for pair, data in exchange_info.items():
        symbol = pair.split('_')[0]  # 永续合约交易对的格式为 BTC_USDT.swap
        
        # 检查该交易对是否为我们要交易的币种，基础货币是否匹配，且是永续合约
        if symbol in Info['trade_symbols'] and pair.split('.')[0].endswith(Info['base_coin']) and pair.endswith('swap'):
            # 获取该交易对的精度信息
            Info['precision'][symbol] = {
                'tick_size': data['TickSize'],                  # 价格精度
                'amount_size': data['AmountSize'],              # 数量精度
                'price_precision': data['PricePrecision'],      # 价格小数位精度
                'amount_precision': data['AmountPrecision'],    # 数量小数位精度
                'min_qty': data['MinQty'],                      # 最小下单数量
                'max_qty': data['MaxQty'],                      # 最大下单数量
                'min_notional': data['MinNotional'],            # 最小交易额
                'ctVal': data['CtVal']                          # 合约价值，如1张代表0.01个币
            }
            
            # 检查合约价值的计价货币是否为symbol，避免币本位情况
            if data['CtValCcy'] != symbol:
                raise Exception("不支持币本位")

GetPrecisionसमारोह：

• ट्रेडिंग जोड़ों के लिए सटीक सेटिंग्स सहित एपीआई के माध्यम से एक्सचेंजों से बाजार की जानकारी प्राप्त करें।
• पात्र व्यापारिक जोड़ों के लिए, मूल्य सटीकता, मात्रा सटीकता, न्यूनतम और अधिकतम लेनदेन मात्रा और अनुबंध मूल्य जैसी जानकारी रिकॉर्ड करें।
• यह जांचता है कि क्या यह एक सिक्का-मार्जिन लेनदेन है और यदि ऐसा है तो अपवाद फेंकता है।

उद्धरण प्राप्त करें

एपीआई के माध्यम से वर्तमान बाज़ार डेटा तक पहुँचें, जैसे कि नवीनतम मूल्य, सर्वोत्तम बोली, सर्वोत्तम पूछताछ और ऑर्डर बुक की गहराई। यह जानकारी आगे के व्यापारिक निर्णयों के लिए महत्वपूर्ण है। रणनीति के आधार पर, यह डेटा कैंडलस्टिक चार्ट (ओएचएलसी डेटा) या टिक-बाय-टिक डेटा पर आधारित हो सकता है।

उद्देश्य:

• वर्तमान बाजार का नवीनतम ट्रेडिंग डेटा प्राप्त करें ताकि रणनीति इस डेटा के आधार पर खरीद और बिक्री के निर्णय ले सके।
• इसमें तकनीकी संकेतक गणना के लिए वास्तविक समय और ऐतिहासिक डेटा का अधिग्रहण शामिल है।

# 更新行情信息
def UpdateTicker():
    
    # 记录当前更新时间戳
    Info['time']['update_ticker_time'] = time.time() * 1000 # 使用time.time()获取当前时间的时间戳
    
    # 遍历获取到的行情数据
    for ticpre in Info['trade_symbols']:
        
        curcontract = ticpre + '_' + QUOTO + '.swap'
        data = exchange.GetTicker(curcontract)
        
        if not data:
            Log("获取行情失败", GetLastError())
            return
        # 提取交易币种，永续合约格式如 'BTC_USDT.swap'，这里取币种名 'BTC'
        symbol = data['Symbol'].split('_')[0]
        
        # 过滤掉不是基础货币(Info['base_coin'])的交易对或不是永续合约的交易对
        if not data['Symbol'].split('.')[0].endswith(Info['base_coin']) or symbol not in Info['trade_symbols'] or not data['Symbol'].endswith('swap'):
            continue
        
        # 更新行情的卖出价、买入价和最后成交价
        Info['ticker'][symbol]['ask'] = float(data['Sell'])  # 卖出价
        Info['ticker'][symbol]['bid'] = float(data['Buy'])   # 买入价
        Info['ticker'][symbol]['last'] = float(data['Last']) # 最后成交价

1. बाज़ार डेटा प्राप्त करें：

   • उपयोगexchange.GetTickersसभी व्यापारिक जोड़ों के लिए वास्तविक समय बाजार जानकारी प्राप्त करें।tickerयह चर सभी लेनदेन युग्म जानकारी संग्रहीत करता है।

2. त्रुटि प्रबंधन：

   • यदि बाजार डेटा सफलतापूर्वक प्राप्त नहीं किया जा सकता है, तो कार्यक्रम पास हो जाता हैLogफ़ंक्शन लॉग और आउटपुट रिकॉर्ड करता हैGetLastErrorत्रुटि संदेश लौटा.

3. अद्यतन समय：

   • उपयोगtime.timeवर्तमान समय का टाइमस्टैम्प रिकॉर्ड करने के लिए, जिसका उपयोग बाजार के अद्यतन होने के समय को चिह्नित करने के लिए किया जाता है।

4. डेटा फ़िल्टरिंग：

   • बाज़ार डेटा से व्यापारिक मुद्रा का नाम निकालें।
   • उन व्यापारिक जोड़ों को फ़िल्टर करें जो आवश्यकताओं को पूरा नहीं करते हैं, जैसे कि वे व्यापारिक जोड़े जो आधार मुद्रा में निपटाए नहीं जाते हैं या वे व्यापारिक जोड़े जो स्थायी अनुबंध नहीं हैं।

5. बाजार डेटा अपडेट करें：

   • योग्य व्यापारिक मुद्राओं के लिए, उनके खरीद मूल्य, बिक्री मूल्य और अंतिम कारोबार मूल्य को अपडेट करें।

इस फ़ंक्शन के माध्यम से, सिस्टम वास्तविक समय में लक्ष्य ट्रेडिंग मुद्रा की नवीनतम बाजार जानकारी प्राप्त और अपडेट कर सकता है।

खाते की स्थिति की जानकारी प्राप्त करें

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

उद्देश्य:

• सुनिश्चित करें कि लेनदेन को निष्पादित करने के लिए आपके खाते में पर्याप्त धनराशि या खुली स्थिति मौजूद है।
• खाते में वर्तमान स्थिति और धनराशि के आधार पर लेनदेन का आकार और दिशा निर्धारित करें।

# 更新账户信息
def UpdateAccount():
   
    # 如果上次更新时间距现在不到1分钟，直接返回
    if time.time() - Info['time']['update_account_time'] < 60:
        return
    
    # 记录账户信息更新时间
    Info['time']['update_account_time'] = time.time() * 1000
    
    # 获取账户信息
    account = exchange.GetAccount()
    
    # 如果账户信息获取失败，记录日志并返回
    if account is None:
        Log("更新账户失败")
        return
    
    # 计算账户信息
    Info['account']['margin_used'] = round(account['Equity'] - account['Balance'], 2)  # 使用的保证金
    Info['account']['margin_balance'] = round(account['Equity'], 2)  # 当前账户余额
    Info['account']['margin_free'] = round(account['Balance'], 2)  # 可用余额
    Info['account']['wallet_balance'] = round(account['Equity'] - account['UPnL'], 2)  # 钱包余额
    Info['account']['unrealised_profit'] = round(account['UPnL'], 2)  # 未实现盈亏

    # 初始化账户初始余额
    if not Info['account']['init_balance']:
        if _G("init_balance") and _G("init_balance") > 0:
            Info['account']['init_balance'] = round(_G("init_balance"), 2)
        else:
            Info['account']['init_balance'] = Info['account']['margin_balance']
            _G("init_balance", Info['account']['init_balance'])
    
    # 计算账户利润及利润率
    Info['account']['profit'] = round(Info['account']['margin_balance'] - Info['account']['init_balance'], 2)
    Info['account']['profit_rate'] = round((100 * Info['account']['profit']) / Info['account']['init_balance'], 2)

    # 计算仓位总价值和杠杆率
    Info['count']['total'] = round(Info['count']['long'] + Info['count']['short'], 2)
    Info['count']['leverage'] = round(Info['count']['total'] / Info['account']['margin_balance'], 2)


# 更新仓位信息
def UpdatePosition():
    
    # 获取永续合约的仓位信息
    pos = exchange.GetPositions(Info['base_coin'] + ".swap")
    
    # 记录仓位信息更新时间
    Info['time']['update_pos_time'] = time.time() * 1000

    # 初始化仓位信息
    position_info = {symbol: {'amount': 0, 'hold_price': 0, 'unrealised_profit': 0} for symbol in Info['trade_symbols']}

    # 遍历仓位信息，更新相应币种的仓位
    for data in pos:
        symbol = data['Symbol'].split("_")[0]
        
        # 过滤掉不符合条件的币种
        if not data['Symbol'].split(".")[0].endswith(Info['base_coin']) or symbol not in Info['trade_symbols']:
            continue
        
        # 如果仓位不为零，则需要单向持仓
        if position_info[symbol]['amount'] != 0:
            raise Exception("需要单向持仓")
        
        # 更新仓位信息
        position_info[symbol] = {
            'amount': data['Amount'] * Info['precision'][symbol]['ctVal'] if data['Type'] == 0 else -data['Amount'] * Info['precision'][symbol]['ctVal'],
            'hold_price': data['Price'],
            'unrealised_profit': data['Profit']
        }

    # 初始化仓位统计数据
    Info['count'] = {'long': 0, 'short': 0, 'total': 0, 'leverage': 0}

    # 遍历更新后的仓位信息
    for symbol, info in position_info.items():
        deal_volume = abs(info['amount'] - Info['position'][symbol]['amount'])
        direction = 1 if info['amount'] - Info['position'][symbol]['amount'] > 0 else -1
        
        # 如果仓位发生变化，记录成交信息
        if deal_volume:
            deal_price = Info['order'][symbol]['buy']['price'] if direction == 1 else Info['order'][symbol]['sell']['price']
            Log(
                symbol,
                "仓位更新：",
                round(Info['position'][symbol]['value'], 1),
                " -> ",
                round(info['amount'] * Info['ticker'][symbol]['last'], 1),
                ", 买" if direction == 1 else ", 卖",
                ", 成交价:",
                deal_price,
                ", 成本价：",
                round(Info['position'][symbol]['hold_price'], Info['precision'][symbol]['price_precision']),
            )

        # 更新仓位信息
        Info['position'][symbol]['amount'] = info['amount']
        Info['position'][symbol]['hold_price'] = info['hold_price']
        Info['position'][symbol]['value'] = round(Info['position'][symbol]['amount'] * Info['ticker'][symbol]['last'], 2)
        Info['position'][symbol]['unrealised_profit'] = info['unrealised_profit']

        # 统计多头和空头仓位价值
        if Info['position'][symbol]['amount'] > 0:
            Info['count']['long'] += abs(Info['position'][symbol]['value'])
        else:
            Info['count']['short'] += abs(Info['position'][symbol]['value'])

1. UpdateAccountसमारोह：

   • अंतराल की जाँच करें: हर बार जब आप अपना खाता अपडेट करते हैं, तो सुनिश्चित करें कि अंतिम अपडेट 1 मिनट से अधिक समय बाद हो ताकि बार-बार अपडेट करने से बचा जा सके।
   • लेखा जानकारी को अद्यतन बनाएं: पुकारनाexchange.GetAccountखाता जानकारी प्राप्त करें और विभिन्न खाता मापदंडों की गणना करें, जैसेmargin_used、wallet_balance、unrealised_profitइंतज़ार।
   • शेष राशि आरंभ करें: खाते को पहली बार चलाते समय उसके प्रारंभिक शेष को आरंभीकृत करें और उसे वैश्विक चर में सहेजेंInfo['account']['init_balance']मध्य।
   • लाभ की गणना: वर्तमान शेष और प्रारंभिक शेष के आधार पर लाभ और लाभ मार्जिन की गणना करता है।

2. UpdatePositionसमारोह：

   • स्थिति की जानकारी प्राप्त करें: पुकारनाexchange.GetPositions()वर्तमान स्थिति की स्थिति प्राप्त करें.
   • स्थिति अपडेट करें：अधिग्रहित स्थिति डेटा (जैसे कि) के आधार पर लक्ष्य मुद्रा की स्थिति जानकारी को अपडेट करेंamount、hold_price、unrealised_profitइंतज़ार)।
   • उत्तोलन की गणनावर्तमान लंबी और छोटी स्थिति मूल्यों और मार्जिन संतुलन के आधार पर समग्र उत्तोलन अनुपात की गणना करता है।

इन दो कार्यों के माध्यम से, रणनीति खाते की स्थिति और स्थिति में परिवर्तन की निरंतर निगरानी कर सकती है, तथा बाद के व्यापारिक निर्णयों के लिए वास्तविक समय डेटा समर्थन प्रदान कर सकती है।

व्यापार

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

उद्देश्य:

• खरीद और बिक्री कार्यों को पूरा करने के लिए एपीआई के माध्यम से ट्रेडिंग निर्देश जारी करें।
• सुनिश्चित करें कि ऑर्डर का प्रकार और मात्रा रणनीति आवश्यकताओं और विनिमय विनियमों के अनुरूप हो।

# 订单函数
def Order(symbol, direction, price, amount, msg):
    pair = f"{symbol}_{Info['base_coin']}.swap"  # 构造交易对名称
    ret = exchange.CreateOrder(pair, direction, price, amount, msg)  # 执行下单操作
    
    # 判断是否下单成功
    if ret:
        Info['order'][symbol][direction]['id'] = ret  # 记录订单ID
        Info['order'][symbol][direction]['price'] = price  # 记录下单价格
    else:
        Log(f"{symbol} {direction} {price} {amount} 下单异常")  # 输出异常信息

# 交易函数
def Trade(symbol, direction, price, amount, msg):
    
    # 根据最小价格变动调整价格
    price = round(price - (price % Info['precision'][symbol]['tick_size']), Info['precision'][symbol]['price_precision'])
    
    # 计算调整后的交易数量
    amount = amount / Info['precision'][symbol]['ctVal']  # 计算真实合约数量
    amount = round(amount - (amount % Info['precision'][symbol]['amount_size']), Info['precision'][symbol]['amount_precision'])

    # 限制最大交易数量
    if Info['precision'][symbol]['max_qty'] > 0:
        amount = min(amount, Info['precision'][symbol]['max_qty'])
    
    new_order = False
    
    # 如果新价格与之前的订单价格差异大于0.0001，则重新下单

    if Info['order'][symbol][direction]['price'] > 0 and abs(price - Info['order'][symbol][direction]['price']) / price > 0.0001:
        Log('已持订单，订单价格发生变化')
        new_order = True
    
    # 如果交易数量为0或者当前订单ID为0，则撤单
    if amount <= 0 or Info['order'][symbol][direction]['id'] == 0:
        Log('新订单产生')
        new_order = True
    
    # 如果需要新订单
    if new_order:
        # 如果有原有订单，撤销它
        if Info['order'][symbol][direction]['id'] != 0:
            exchange.CancelOrder(Info['order'][symbol][direction]['id'])
            Info['order'][symbol][direction]['id'] = 0
            Info['order'][symbol][direction]['price'] = 0
            Log('撤单成功：', symbol)
        
        
        # 如果更新仓位或ticker的延迟太高，则不下单
        if (time.time() * 1000 - Info['time']['update_pos_time'] > 2 * Info['interval'] * 1000 or 
            time.time() * 1000 - Info['time']['update_ticker_time'] > 2 * Info['interval'] * 1000):
            Log(time.time() * 1000, Info['time']['update_pos_time'], time.time() * 1000 - Info['time']['update_pos_time'])
            Log(time.time() * 1000, Info['time']['update_ticker_time'], time.time() * 1000 - Info['time']['update_ticker_time'])
            Log('延迟过高')
            return
        
        # 如果订单金额或数量过低，不执行下单操作
        if price * amount <= Info['precision'][symbol]['min_notional'] or amount < Info['precision'][symbol]['min_qty']:
            Log(f"{symbol} 下单量太低", price * amount)
            return
        
        # 执行下单操作
        Log('order下单:', symbol)
        Order(symbol, direction, price, amount, msg)

1. Orderसमारोह：

   • ऑर्डर बनाने के लिए ज़िम्मेदार। सफल होने पर, यह ऑर्डर आईडी और कीमत रिकॉर्ड करेगा। असफल होने पर, यह एक त्रुटि संदेश प्रदर्शित करेगा।

2. Tradeसमारोह：

   • बाजार मूल्य और मात्रा के आधार पर समायोजन करें, ताकि यह निर्धारित किया जा सके कि ऑर्डर को रद्द करना है या नहीं और ऑर्डर निष्पादन त्रुटियों या बार-बार संचालन से बचने के लिए नया ऑर्डर देना है या नहीं।

3. CancelOrderसमारोह：

   • यह एक अनुकूलित ऑर्डर रद्दीकरण ऑपरेशन है, जो वर्तमान लंबित ऑर्डर को रद्द करने के लिए जिम्मेदार है।

स्थिति प्रदर्शन

रणनीति की परिचालन स्थिति वास्तविक समय में प्रदर्शित की जाती है, जिसमें खाता शेष, वर्तमान स्थिति, व्यापार निष्पादन स्थिति, वर्तमान बाजार मूल्य आदि शामिल हैं। यह कदम न केवल रणनीति के संचालन की निगरानी के लिए है, बल्कि रणनीति अनुकूलन और डिबगिंग के दौरान रणनीति के प्रदर्शन को जल्दी से समझने के लिए भी है।

उद्देश्य:

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

# 更新状态函数
def UpdateStatus():
    
    # 如果距离上次更新的时间小于4秒，则直接返回
    if time.time() * 1000 - Info['time']['update_status_time'] < 4000:
        return
    
    # 更新状态时间
    Info['time']['update_status_time'] = time.time() * 1000

    # 账户信息表格
    table1 = {
        "type": "table",
        "title": "账户信息",
        "cols": [
            "初始余额", "钱包余额", "保证金余额", "已用保证金", "可用保证金",
            "总收益", "收益率", "未实现收益", "总持仓", "已用杠杆", "循环延时"
        ],
        "rows": [
            [
                Info['account']['init_balance'],  # 初始余额
                Info['account']['wallet_balance'],  # 钱包余额
                Info['account']['margin_balance'],  # 保证金余额
                Info['account']['margin_used'],  # 已用保证金
                Info['account']['margin_free'],  # 可用保证金
                Info['account']['profit'],  # 总收益
                str(Info['account']['profit_rate']) + "%",  # 收益率
                round(Info['account']['unrealised_profit'], 2),  # 未实现收益
                round(Info['count']['total'], 2),  # 总持仓
                Info['count']['leverage'],  # 已用杠杆
                str(Info['time']['loop_delay']) + "ms",  # 循环延时
            ],
        ],
    }
    
    # 交易对信息表格
    table2 = {
        "type": "table",
        "title": "交易对信息",
        "cols": [
            "币种", "方向", "数量", "持仓价格", "持仓价值", 
            "现价", "挂单买价", "挂单卖价", "未实现盈亏"
        ],
        "rows": [],
    }

    # 遍历每个交易对，填充交易对信息
    for symbol in Info['trade_symbols']:
        table2['rows'].append([
            symbol,  # 币种
            "LONG" if Info['position'][symbol]['amount'] > 0 else "SHORT",  # 方向
            round(Info['position'][symbol]['amount'], Info['precision'][symbol]['amount_precision'] + 2),  # 数量
            round(Info['position'][symbol]['hold_price'], Info['precision'][symbol]['price_precision']),  # 持仓价格
            round(Info['position'][symbol]['value'], 2),  # 持仓价值
            round(Info['ticker'][symbol]['last'], Info['precision'][symbol]['price_precision']),  # 现价
            Info['order'][symbol]['buy']['price'],  # 挂单买价
            Info['order'][symbol]['sell']['price'],  # 挂单卖价
            round(Info['position'][symbol]['unrealised_profit'], 2),  # 未实现盈亏
        ])

    # 输出状态日志
    LogStatus(
        f"初始化时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(Info['time']['start_time']))}\n",
        f"`{json.dumps(table1)}`\n" + f"`{json.dumps(table2)}`\n",
        f"最后执行时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}\n"
    )

    # 每10秒钟更新一次账户信息
    if time.time() * 1000 - Info['time']['update_profit_time'] > 10 * 1000:
        UpdateAccount()  # 更新账户信息
        LogProfit(round(Info['account']['profit'], 3), '&')  # 输出收益日志
        Info['time']['update_profit_time'] = time.time() * 1000  # 更新收益时间

लेन-देन तर्क

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

उद्देश्य:

• बाजार डेटा और खाता स्थिति के आधार पर बुद्धिमानी से व्यापारिक निर्णय लें।
• विभिन्न बाजार स्थितियों को संभालना और यह सुनिश्चित करना कि रणनीतियाँ विभिन्न बाजार परिवेशों में उचित रूप से संचालित हो सकें।

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

def MakeOrder():
    
    # 遍历所有交易对
    for symbol in Info['trade_symbols']:
        
        # 获取买价（挂单买价）
        buy_price = Info['ticker'][symbol]['bid']
        
        # 计算买入数量，根据买入金额除以买价
        buy_amount = 50 / buy_price

        # 获取卖价（挂单卖价）
        sell_price = Info['ticker'][symbol]['ask']
        
        # 计算买入数量，根据买入金额除以买价
        sell_amount = 50 / sell_price

        
        # 如果当前持仓的总价值小于2000，则进行买入操作
        if Info['position'][symbol]['value'] < 2000:
            Log('进入交易')
            Log('设定价格：', Info['ticker'][symbol]['bid'])
            Trade(symbol, "buy", buy_price, buy_amount, symbol)  # 执行买入操作
        
        #if Info['position'][symbol]['value'] < 3000:
        #    Trade(symbol, "sell", sell_price, sell_amount, symbol)  # 执行买入操作

मुख्य घेरा

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

उद्देश्य:

• रणनीति के निरंतर और स्थिर संचालन को सुनिश्चित करें, वास्तविक समय में बाजार डेटा प्राप्त करें और व्यापारिक निर्णय लें।
• प्रत्येक चक्र रणनीति के क्रियान्वयन की वास्तविक समय और सटीकता सुनिश्चित करता है।

def OnTick():
    try:
        # 更新市场行情信息
        UpdateTicker()
        # 更新持仓信息
        UpdatePosition()
        # 执行下单操作
        MakeOrder()
        # 更新状态信息
        UpdateStatus()
    except Exception as error:
        # 记录循环中发生的错误
        Log("循环出错: " + str(error))

def main():
    LogReset(0)  
    apiBase = "https://testnet.binancefuture.com"  # 币安期货仿真交易所        
    exchange.SetBase(apiBase)  # 设置仿真交易所基站
    # 初始化信息
    exchange.IO('dual', False)  # 单向持仓
    InitInfo()
    GetPrecision()
    
    while True:  # 无限循环
        loop_start_time = time.time() * 1000  # 获取当前时间（毫秒）
        
        # 检查上次循环时间与设定的间隔时间是否已过
        if time.time() * 1000 - Info['time']['last_loop_time'] > Info['interval'] * 1000:
            OnTick()  # 调用 OnTick 函数
            
            # 更新最后一次循环时间
            Info['time']['last_loop_time'] = time.time() * 1000
            # 计算当前循环的延迟时间
            Info['time']['loop_delay'] = time.time() * 1000 - loop_start_time
        
        # 暂停5毫秒，避免过度消耗CPU资源
        Sleep(5000)

कोड स्पष्टीकरण:

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

2. mainसमारोहमुख्य फ़ंक्शन संबंधित जानकारी को आरंभ करता है, एक्सचेंज बेस स्टेशन सेट करता है और एक अनंत लूप शुरू करता है। प्रत्येक लूप में, प्रोग्राम जाँचता है कि क्या निर्धारित समय अंतराल बीत चुका है। यदि हाँ, तोOnTickरणनीति को क्रियान्वित करने के लिए फ़ंक्शन को कॉल किया जाएगा। यदि समय अंतराल अभी तक नहीं आया है, तो प्रोग्राम प्रतीक्षा करेगा और लूप जारी रखेगा ताकि यह सुनिश्चित हो सके कि रणनीति पूर्वनिर्धारित समय अंतराल के अनुसार क्रियान्वित हो।

3. विलंब नियंत्रणप्रत्येक लूप के बाद, प्रोग्राम CPU लोड को कम करने के लिए 5 मिलीसेकंड के लिए रुकता है। ऐसा उच्च-आवृत्ति वाले लूप के कारण कंप्यूटिंग संसाधनों की अत्यधिक खपत से बचने के लिए किया जाता है।

संचालन तर्क

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

यह मुख्य लूप डिजाइन यह सुनिश्चित करता है कि रणनीति वास्तविक समय की बाजार स्थितियों के तहत चलती रहे और समय पर व्यापारिक निर्णय ले, जिससे रणनीति की स्थिरता और सटीकता में सुधार हो।

संक्षेप

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

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