파이썬 버전 아이스버그 위원회 전략

이 문서에서는 이식을위한 두 가지 고전적인 전략을 소개합니다: 아이스버그 위원회 (구매/판매). 전략은 FMZ 플랫폼의 아이스버그 위원회 자바스크립트 버전에서 이식되었습니다. 전략 주소는https://www.fmz.com/square/s:Iceberg/1

아이스버그 수수료 거래 전략 소개의 자바스크립트 버전을 인용:

아이스버그 위원회는 투자자가 큰 규모의 거래를 할 때 시장에 과도한 영향을 피하기 위해 큰 주문 수수료를 현재 최신 구매 / 판매 1 가격과 거래자가 설정한 가격에 따라 자동으로 여러 수수료로 나눈다는 사실을 의미합니다. 전략은 자동으로 작은 주문을 수수료로합니다. 마지막 수수료가 완전히 거래되거나 최신 가격이 현재 수수료 가격에서 크게 벗어나면 수수료 작업이 자동으로 다시 시작됩니다.

많은 거래소 거래 페이지에는 풍부한 기능을 갖춘 아이스버그 위탁 도구가 제공됩니다. 그러나 일부 기능을 사용자 정의하거나 자신의 필요에 따라 일부 기능을 수정하려면 더 유연한 도구가 필요합니다. FMZ 플랫폼은이 문제를 올바르게 해결하도록 설계되었습니다. 우리의 전략 광장은 너무 많은 파이썬 거래 전략을 가지고 없습니다. 거래 도구와 전략을 작성하기 위해 파이썬 언어를 사용하려는 일부 거래자는 예제를 참조해야합니다. 따라서 고전적인 아이스버그 위탁 전략은 파이썬 버전으로 포팅되었습니다.

아이스버그 파이썬 위원회 - 구매

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.

아이스버그 파이썬 위원회 - 판매

전략 논리는 구매와 동일하지만 약간의 차이점만 있습니다.

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

전략 작전

WexApp를 사용하여 교환 테스트를 시뮬레이션합니다.

구매:

판매:

전략 논리는 복잡하지 않습니다. 전략이 실행되면 전략 매개 변수 및 현재 시장 가격에 따라 주문을 동적으로 배치하고 취소합니다. 거래 금액 / 동전 번호가 매개 변수 설정 번호에 도달하거나 접근하면 전략이 중단됩니다. 전략 코드는 매우 간단하고 초보자에게 적합합니다. 관심있는 독자는 수정하고 자신의 거래 스타일에 맞는 전략을 설계 할 수 있습니다.