Phiên bản Python chiến lược iceberg ủy ban

Bài viết này đưa ra hai chiến lược cổ điển cho cấy ghép: Iceberg commission (mua / bán). Chiến lược được cấy ghép từ phiên bản JavaScript của nền tảng FMZ. Địa chỉ chiến lược làhttps://www.fmz.com/square/s:Iceberg/1

trích dẫn phiên bản JavaScript của Iceberg phần thưởng chiến lược giao dịch giới thiệu:

Iceberg commission đề cập đến thực tế là khi các nhà đầu tư thực hiện các giao dịch có giá trị lớn, để tránh tác động quá mức đến thị trường, hoa hồng lệnh lớn tự động được chia thành nhiều hoa hồng, dựa trên giá mua / bán 1 gần nhất hiện tại và giá được trader đặt. Chiến lược tự động ủy quyền một lệnh nhỏ. Khi hoa hồng cuối cùng được giao dịch hoàn toàn hoặc giá mới nhất lệch đáng kể so với giá hoa hồng hiện tại, hoạt động hoa hồng sẽ tự động bắt đầu lại.

Nhiều trang giao dịch trao đổi đi kèm với các công cụ ủy thác băng trôi, có chức năng phong phú, nhưng nếu bạn muốn tùy chỉnh một số chức năng hoặc sửa đổi một số chức năng theo nhu cầu của riêng bạn, bạn cần một công cụ linh hoạt hơn. Nền tảng FMZ được thiết kế để giải quyết vấn đề này một cách chính xác. Quảng trường chiến lược của chúng tôi không có quá nhiều chiến lược giao dịch Python. Một số thương nhân muốn sử dụng ngôn ngữ Python để viết các công cụ và chiến lược giao dịch cần tham khảo các ví dụ. Do đó, chiến lược ủy thác băng trôi cổ điển đã được chuyển sang phiên bản Python.

Ủy ban Iceberg cho Python - Mua

import random  # Import random number library

def CancelPendingOrders():     # The function of CancelPendingOrders is to cancel all pending orders of the current transaction.
    while True:                # Loop detection, call GetOrders function to detect the current pending order, if orders is an empty array, that is, len(orders) is equal to 0, indicating that all orders have been cancelled, you can exit the function and call return to exit.
        orders = _C(exchange.GetOrders)
        if len(orders) == 0 :
            return 

        for j in range(len(orders)):     # Traverse the current array of pending orders, and call CancelOrder to cancel the orders one by one.
            exchange.CancelOrder(orders[j]["Id"])
            if j < len(orders) - 1:      # Except for the last order, execute Sleep every time and let the program wait for a while to avoid canceling orders too frequently.
                Sleep(Interval)

LastBuyPrice = 0       # Set a global variable to record the the latest buying price.
InitAccount = None     # Set a global variable to record the initial account asset information.

def dispatch():        # Main functions of iceberg commission logic
    global InitAccount, LastBuyPrice     # Reference global variables
    account = None                       # Declare a variable to record the account information obtained in real time for comparison calculation.
    ticker = _C(exchange.GetTicker)      # Declare a variable to record the latest market quotes.
    LogStatus(_D(), "ticker:", ticker)   # Output time and latest quotation in the status bar
    if LastBuyPrice > 0:                 # When LastBuyPrice is greater than 0, that is, when the commission has started, the code in the if condition is executed.
        if len(_C(exchange.GetOrders)) > 0:    # Call the exchange.GetOrders function to get all current pending orders, determine that there are pending orders, and execute the code in the if condition.
            if ticker["Last"] > LastBuyPrice  and ((ticker["Last"] - LastBuyPrice) / LastBuyPrice) > (2 * (EntrustDepth / 100)):   # Detect the degree of deviation, if the condition is triggered, execute the code in the if, and cancel the order.
                Log("Too much deviation, the latest transaction price:", ticker["Last"], "Commission price", LastBuyPrice)
                CancelPendingOrders()
            else :
                return True
        else :    # If there is no pending order, it proves that the order is completely filled.
            account = _C(exchange.GetAccount)     # Get current account asset information.
            Log("The buying order is completed, the cumulative cost:", _N(InitAccount["Balance"] - account["Balance"]), "Average buying price:", _N((InitAccount["Balance"] - account["Balance"]) / (account["Stocks"] - InitAccount["Stocks"])))  # Print transaction information.
        LastBuyPrice = 0   # Reset LastBuyPrice to 0

    BuyPrice = _N(ticker["Buy"] * (1 - EntrustDepth / 100))   # Calculate the price of pending orders based on current market conditions and parameters.
    if BuyPrice > MaxBuyPrice:    # Determine whether the maximum price set by the parameter is exceeded
        return True

    if not account:               # If account is null, execute the code in the if statement to retrieve the current asset information and copy it to account
        account = _C(exchange.GetAccount)

    if (InitAccount["Balance"] - account["Balance"]) >= TotalBuyNet:  # Determine whether the total amount of money spent on buying exceeds the parameter setting.
        return False

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

    BuyAmount = _N(UsedMoney / BuyPrice)   # Calculate the buying quantity
    if BuyAmount < MinStock:         # Determine whether the buying quantity is less than the minimum buying quantity limit on the parameter.
        return False 
    LastBuyPrice = BuyPrice          # Record the price of this order and assign it to LastBuyPrice
    exchange.Buy(BuyPrice, BuyAmount, "spend:￥", _N(UsedMoney), "Last transaction price", ticker["Last"]) # Place orders
    return True

def main():
    global LoopInterval, InitAccount    # Refer to LoopInterval, InitAccount global variables
    CancelPendingOrders()               # Cancel all pending orders when starting to run
    InitAccount = _C(exchange.GetAccount)   # Account assets at the beginning of the initial record
    Log(InitAccount)                        # Print initial account information
    if InitAccount["Balance"] < TotalBuyNet:    # If the initial assets are insufficient, an error will be thrown and the program will stop
        raise Exception("Insufficient account balance")
    LoopInterval = max(LoopInterval, 1)      # Set LoopInterval to at least 1
    while dispatch():                        # The main loop, the iceberg commission logic function dispatch is called continuously, and the loop stops when the dispatch function returns false.
        Sleep(LoopInterval * 1000)           # Pause each cycle to control the polling frequency.
    Log("委托全部完成", _C(exchange.GetAccount))   # When the loop execution jumps out, the current account asset information is printed.

Ủy ban Iceberg cho Python - Bán

Lý thuyết chiến lược giống như mua, chỉ có một sự khác biệt nhỏ.

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("Too much deviation, the latest transaction price:", ticker["Last"], "Commission price", LastSellPrice)
                CancelPendingOrders()
            else :
                return True
        else :
            account = _C(exchange.GetAccount)
            Log("The buy order is completed, and the accumulated selling:", _N(InitAccount["Stocks"] - account["Stocks"]), "Average selling price:", _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, "Last transaction price", ticker["Last"])
    return True

def main():
    global InitAccount, LoopInterval
    CancelPendingOrders()
    InitAccount = _C(exchange.GetAccount)
    Log(InitAccount)
    if InitAccount["Stocks"] < TotalSellStocks:
        raise Exception("Insufficient account currency")
    LoopInterval = max(LoopInterval, 1)
    while dispatch():
        Sleep(LoopInterval)
    Log("All commissioned", _C(exchange.GetAccount))

Hoạt động chiến lược

Sử dụng WexApp để mô phỏng thử nghiệm trao đổi:

Mua:

Bán:

Khái niệm chiến lược không phức tạp. Khi chiến lược được thực hiện, nó sẽ động đặt và hủy lệnh dựa trên các tham số chiến lược và giá thị trường hiện tại. Khi số lượng giao dịch / số tiền xu đạt hoặc tiếp cận số thiết lập tham số, chiến lược dừng lại. Mã chiến lược rất đơn giản và phù hợp cho người mới bắt đầu. Người đọc quan tâm có thể sửa đổi nó và thiết kế một chiến lược phù hợp với phong cách giao dịch của họ.