آئیس مونڈر تفویض کی حکمت عملی

آئیس مونڈر تفویض کی حکمت عملی

اس مضمون میں ، نقل و حمل کی دو کلاسک حکمت عملیوں کو پیش کیا گیا ہے: آئس کانگ تفویض ((خرید / فروخت) ؛ حکمت عملی نقل و حمل کے لئے ایجاد کنندہ سے مقداری تجارتی پلیٹ فارم کلاسک حکمت عملی جاوا اسکرپٹ ورژن آئس کانگ تفویض ، حکمت عملی کا پتہ:https://www.fmz.com/square/s:冰山委托/1 。

جاوا اسکرپٹ ورژن کی پالیسی کا حوالہ دیتے ہوئے:

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

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

پائیتھون ایڈیشن آئس مینڈک تفویض - خریداری حکمت عملی کا کوڈ اور تشریح

import random  # 导入随机数库

def CancelPendingOrders():     # CancelPendingOrders 函数作用是取消当前交易对所有挂单。
    while True:                # 循环检测，调用GetOrders 函数，检测当前挂单，如果orders 为空数组，即len(orders) 等于0，说明订单全部取消了，可以退出函数，调用return 退出。
        orders = _C(exchange.GetOrders)
        if len(orders) == 0 :
            return 

        for j in range(len(orders)):     # 遍历当前挂单数组，调用取消订单的函数CancelOrder,逐个取消挂单。
            exchange.CancelOrder(orders[j]["Id"])
            if j < len(orders) - 1:      # 除了最后一个订单，每次都执行Sleep 让程序等待一会儿，避免撤单过于频繁。
                Sleep(Interval)

LastBuyPrice = 0       # 设置一个全局变量，记录最近一次买入的价格。
InitAccount = None     # 设置一个全局变量，记录初始账户资产信息。

def dispatch():        # 冰山委托逻辑的主要函数
    global InitAccount, LastBuyPrice     # 引用全局变量
    account = None                       # 声明一个变量，记录实时获取的账户信息，用于对比计算。
    ticker = _C(exchange.GetTicker)      # 声明一个变量，记录最近行情。
    LogStatus(_D(), "ticker:", ticker)   # 在状态栏输出时间，最新行情
    if LastBuyPrice > 0:                 # 当LastBuyPrice大于0时，即已经委托开始时，执行if条件内代码。
        if len(_C(exchange.GetOrders)) > 0:    # 调用exchange.GetOrders 函数获取当前所有挂单，判断有挂单，执行if条件内代码。
            if ticker["Last"] > LastBuyPrice  and ((ticker["Last"] - LastBuyPrice) / LastBuyPrice) > (2 * (EntrustDepth / 100)):   # 检测偏离程度，如果触发该条件，执行if内代码，撤单。
                Log("偏离过多, 最新成交价:", ticker["Last"], "委托价", LastBuyPrice)
                CancelPendingOrders()
            else :
                return True
        else :    # 如果没有挂单，证明订单完全成交了。
            account = _C(exchange.GetAccount)     # 获取当前账户资产信息。
            Log("买单完成, 累计花费:", _N(InitAccount["Balance"] - account["Balance"]), "平均买入价:", _N((InitAccount["Balance"] - account["Balance"]) / (account["Stocks"] - InitAccount["Stocks"])))  # 打印交易信息。
        LastBuyPrice = 0   # 重置 LastBuyPrice为0

    BuyPrice = _N(ticker["Buy"] * (1 - EntrustDepth / 100))   # 通过当前行情和参数，计算挂单价格。
    if BuyPrice > MaxBuyPrice:    # 判断是否超过参数设置的最大价格
        return True

    if not account:               # 如果 account 为 null ,执行if 语句内代码，重新获取当前资产信息，复制给account
        account = _C(exchange.GetAccount)

    if (InitAccount["Balance"] - account["Balance"]) >= TotalBuyNet:  # 判断买入所花费的总钱数，是不是超过参数设置。
        return False

    RandomAvgBuyOnce = (AvgBuyOnce * ((100.0 - FloatPoint) / 100.0)) + (((FloatPoint * 2) / 100.0) * AvgBuyOnce * random.random())   # 随机数 0~1
    UsedMoney = min(account["Balance"], RandomAvgBuyOnce, TotalBuyNet - (InitAccount["Balance"] - account["Balance"]))

    BuyAmount = _N(UsedMoney / BuyPrice)   # 计算买入数量
    if BuyAmount < MinStock:         # 判断买入数量是否小于 参数上最小买入量限制。
        return False 
    LastBuyPrice = BuyPrice          # 记录本次下单价格，赋值给LastBuyPrice
    exchange.Buy(BuyPrice, BuyAmount, "花费：￥", _N(UsedMoney), "上次成交价", ticker["Last"]) # 下单
    return True

def main():
    global LoopInterval, InitAccount    # 引用 LoopInterval, InitAccount 全局变量
    CancelPendingOrders()               # 开始运行时，取消所有挂单
    InitAccount = _C(exchange.GetAccount)   # 初始记录 开始时的账户资产
    Log(InitAccount)                        # 打印初始账户信息
    if InitAccount["Balance"] < TotalBuyNet:    # 如果初始时资产不足，则抛出错误，停止程序
        raise Exception("账户余额不足")
    LoopInterval = max(LoopInterval, 1)      # 设置LoopInterval至少为1
    while dispatch():                        # 主要循环，不停调用 冰山委托逻辑函数 dispatch ，当dispatch函数 return false 时才停止循环。
        Sleep(LoopInterval * 1000)           # 每次循环都暂停一下，控制轮询频率。
    Log("委托全部完成", _C(exchange.GetAccount))   # 当循环执行跳出时，打印当前账户资产信息。

پیتھون ورژن آئس مینڈک - فروخت

آپ کو کوشش کر سکتے ہیں، کوڈ کو پڑھتے ہیں "پائتون ایڈیشن آئس لینڈ کو تفویض - فروخت، حکمت عملی کی منطق اور خریدنے کے لئے ایک ہی ہے، صرف ایک چھوٹا سا فرق ہے. "

import random

def CancelPendingOrders():
    while True:
        orders = _C(exchange.GetOrders)
        if len(orders) == 0:
            return
        
        for j in range(len(orders)):
            exchange.CancelOrder(orders[j]["Id"])
            if j < len(orders) - 1:
                Sleep(Interval)

LastSellPrice = 0
InitAccount = None

def dispatch():
    global LastSellPrice, InitAccount
    account = None
    ticker = _C(exchange.GetTicker)
    LogStatus(_D(), "ticker:", ticker)   
    if LastSellPrice > 0:
        if len(_C(exchange.GetOrders)) > 0:
            if ticker["Last"] < LastSellPrice and ((LastSellPrice - ticker["Last"]) / ticker["Last"]) > (2 * (EntrustDepth / 100)):
                Log("偏离过多，最新成交价：", ticker["Last"], "委托价", LastSellPrice)
                CancelPendingOrders()
            else :
                return True
        else :
            account = _C(exchange.GetAccount)
            Log("买单完成，累计卖出：", _N(InitAccount["Stocks"] - account["Stocks"]), "平均卖出价：", _N((account["Balance"] - InitAccount["Balance"]) / (InitAccount["Stocks"] - account["Stocks"])))
            LastSellPrice = 0

    SellPrice = _N(ticker["Sell"] * (1 + EntrustDepth / 100))
    if SellPrice < MinSellPrice:
        return True

    if not account:
        account = _C(exchange.GetAccount)

    if (InitAccount["Stocks"] - account["Stocks"]) >= TotalSellStocks:
        return False 

    RandomAvgSellOnce = (AvgSellOnce * ((100.0 - FloatPoint) / 100.0)) + (((FloatPoint * 2) / 100.0) * AvgSellOnce * random.random())
    SellAmount = min(TotalSellStocks - (InitAccount["Stocks"] - account["Stocks"]), RandomAvgSellOnce)
    if SellAmount < MinStock:
        return False 

    LastSellPrice = SellPrice
    exchange.Sell(SellPrice, SellAmount, "上次成交价", ticker["Last"])
    return True

def main():
    global InitAccount, LoopInterval
    CancelPendingOrders()
    InitAccount = _C(exchange.GetAccount)
    Log(InitAccount)
    if InitAccount["Stocks"] < TotalSellStocks:
        raise Exception("账户币数不足")
    LoopInterval = max(LoopInterval, 1)
    while dispatch():
        Sleep(LoopInterval)
    Log("委托全部完成", _C(exchange.GetAccount))

حکمت عملی کام کر رہی ہے

ہم نے یہ تجربہ WexApp کے ساتھ کیا: خریدنا

فروخت

حکمت عملی کی منطق پیچیدہ نہیں ہے ، حکمت عملی کے عمل کے دوران ، حکمت عملی کے پیرامیٹرز ، اس وقت مارکیٹ کی قیمت ، متحرک آرڈر لگانے ، واپس لینے کے مطابق ؛ جب تجارت کی رقم / سکے کی تعداد پہنچ جاتی ہے ، جب پیرامیٹر کی ترتیب کی تعداد کے قریب ہوتی ہے تو حکمت عملی رک جاتی ہے۔ حکمت عملی کا کوڈ بہت آسان ہے ، ابتدائیوں کے لئے موزوں ہے۔ دلچسپی رکھنے والے ساتھی اسے تبدیل کرسکتے ہیں ، اور اپنی تجارت کے انداز کے مطابق حکمت عملی تیار کرسکتے ہیں۔ اس کی حکمت عملی تعلیمی نوعیت کی ہے اور اسے احتیاط سے استعمال کریں۔