introdução:

Recentemente, um usuário do professor XiaocaoComo construir rapidamente uma estratégia universal de negociação multimoeda após a atualização do FMZDeixe um comentário na seção de comentários deste artigo, na esperança de fornecer uma implementação em Python desta estrutura estratégica. Para atender às necessidades dos desenvolvedores Python, este artigo se baseará nas ideias originais de Xiaocao e as combinará com o ambiente de negociação simulado da Binance para explicar em detalhes como construir uma estrutura universal de negociação quantitativa multimoeda.

Esta estrutura possui as seguintes características:

• Baseado na linguagem Python, fácil de entender e expandir
• Suporte a transações simultâneas em várias moedas
• Usando a exchange simulada da Binance para testes de segurança
• Fornece exemplos de código completos e comentários detalhados

Esperamos que este artigo ajude você a começar rapidamente com a negociação quantitativa multimoeda. Também convidamos desenvolvedores a inovar e otimizar com base nessa experiência, criando estratégias de negociação ainda mais abrangentes e personalizadas. Vamos continuar explorando o caminho da negociação quantitativa juntos!

Estratégia de inicialização

Na fase de inicialização da estratégia de negociação, primeiro definimos as variáveis ​​globaisSYMBOLS，QUOTO，INTERVAL, representa a moeda de transação de destino, a moeda base e o tempo de intervalo,InfoVariáveis ​​são usadas para armazenar todos os dados principais necessários durante a operação da estratégia.InitInfoA função inicializa esses dados, incluindo informações da conta, gerenciamento de tempo, dados de mercado para cada moeda de negociação, informações de pedidos, informações de posição, etc. Essas etapas de inicialização garantem que a estratégia tenha uma estrutura de dados e um estado inicial claros quando estiver em execução, estabelecendo a base para a execução subsequente da estratégia.

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
        }

Obtenha informações de mercado e defina a precisão

Esta etapa garante que a precisão dos preços, quantidades e outros aspectos das moedas que processamos, bem como a quantidade das ordens, atenda aos padrões da corretora. Diferentes pares de negociação (como BTC/USD ou ETH/USDT) têm diferentes requisitos mínimos de precisão para preços e quantidades, portanto, precisamos obter essas informações de precisão da API da corretora para evitar ordens não conformes. Por exemplo, ETH/USDT pode permitir duas casas decimais, enquanto BTC/USDT pode permitir oito casas decimais.

Objetivo:

• Obtenha precisão de preço e quantidade para cada moeda para garantir a precisão dos dados do pedido.
• Evite falhas de pedidos devido a erros de precisão.

# 获取精度信息
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("不支持币本位")

GetPrecisionfunção：

• Obtenha informações de mercado de bolsas por meio de APIs, incluindo configurações de precisão para pares de negociação.
• Para pares de negociação qualificados, registre informações como precisão de preço, precisão de quantidade, volumes mínimos e máximos de transação e valor do contrato.
• Verifica se é uma transação com margem em moeda e gera uma exceção se for o caso.

Obter cotações

Acesse dados atuais do mercado por meio da API, como o preço mais recente, o melhor bid, o melhor ask e a profundidade do livro de ordens. Essas informações são cruciais para decisões de negociação subsequentes. Dependendo da estratégia, esses dados podem ser baseados em gráficos de velas (dados OHLC) ou em dados tick-by-tick.

Objetivo:

• Obtenha os dados de negociação mais recentes do mercado atual para que a estratégia possa tomar decisões de compra e venda com base nesses dados.
• Contém a aquisição de dados históricos e em tempo real para cálculos de indicadores técnicos.

# 更新行情信息
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. Obtenha dados de mercado：

   • usarexchange.GetTickersObtenha informações de mercado em tempo real para todos os pares de negociação.tickerA variável armazena todas as informações do par de transações.

2. Tratamento de erros：

   • Se os dados de mercado não puderem ser obtidos com sucesso, o programa passaLogLogs e saídas de funçõesGetLastErrorA mensagem de erro foi retornada.

3. Hora de atualização：

   • usartime.timePara registrar o registro de data e hora atual, que é usado para marcar o momento em que o mercado é atualizado.

4. Filtragem de dados：

   • Extraia o nome da moeda de negociação dos dados de mercado.
   • Filtre pares de negociação que não atendem aos requisitos, como pares de negociação que não são liquidados na moeda base ou pares de negociação que não são contratos perpétuos.

5. Atualizar dados de mercado：

   • Para moedas de negociação qualificadas, atualize o preço de compra, o preço de venda e o último preço negociado.

Por meio dessa função, o sistema pode obter e atualizar as informações de mercado mais recentes da moeda de negociação alvo em tempo real.

Obter informações sobre a posição da conta

Use a API para recuperar o saldo da sua conta e os ativos atuais (moeda, quantidade, custo, etc.). Esta etapa é crucial para avaliar os fundos disponíveis, calcular o risco e gerenciar posições. Por exemplo, seus ativos atuais determinarão se você deve aumentar ou diminuir sua posição.

Objetivo:

• Certifique-se de que há fundos suficientes ou posições abertas em sua conta para executar a transação.
• Determine o tamanho e a direção da transação com base na posição atual e nos fundos na conta.

# 更新账户信息
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. UpdateAccountfunção：

   • Intervalo de verificação: Toda vez que você atualizar sua conta, certifique-se de que a última atualização esteja a mais de 1 minuto de distância para evitar atualizações com muita frequência.
   • Atualizar informações da conta: Chamarexchange.GetAccountObtenha informações da conta e calcule vários parâmetros da conta, comomargin_used、wallet_balance、unrealised_profitespere.
   • Inicializar saldo: Inicialize o saldo inicial da conta quando ela for executada pela primeira vez e salve-o na variável globalInfo['account']['init_balance']meio.
   • Calculando Lucros: Calcula o lucro e a margem de lucro com base no saldo atual e no saldo inicial.

2. UpdatePositionfunção：

   • Obter informações de posição: Chamarexchange.GetPositions()Obtenha o status da posição atual.
   • Atualizar posição：Atualize as informações de posição da moeda de destino com base nos dados de posição adquiridos (comoamount、hold_price、unrealised_profitespere).
   • Calculando a alavancagemCalcula o índice de alavancagem geral com base nos valores atuais das posições longas e curtas e no saldo de margem.

Por meio dessas duas funções, a estratégia pode monitorar continuamente o status da conta e as mudanças de posição, fornecendo suporte de dados em tempo real para decisões de negociação subsequentes.

troca

Execute ordens de compra ou venda com base na lógica da estratégia. Podem ser ordens de mercado, ordens limitadas ou outros tipos de ordens. Esta etapa envolve a interação com a API da corretora para enviar solicitações de compra ou venda. A execução bem-sucedida da ordem afeta o saldo e o interesse em aberto da conta.

Objetivo:

• Emita instruções de negociação por meio de API para concluir operações de compra e venda.
• Garanta que o tipo e a quantidade do pedido estejam em conformidade com os requisitos da estratégia e os regulamentos de câmbio.

# 订单函数
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. Orderfunção：

   • Responsável por criar um pedido. Se for bem-sucedido, registrará o ID do pedido e o preço. Se falhar, emitirá uma mensagem de erro.

2. Tradefunção：

   • Ajuste com base no preço de mercado e na quantidade para determinar se deve cancelar o pedido e fazer um novo para evitar erros de execução do pedido ou operações repetidas.

3. CancelOrderfunção：

   • É uma operação de cancelamento de pedido personalizada, responsável por cancelar o pedido pendente atual.

Exibição de status

O status operacional da estratégia é exibido em tempo real, incluindo saldo da conta, posições atuais, status de execução da negociação, preço de mercado atual, etc. Esta etapa não serve apenas para monitorar a operação da estratégia, mas também para entender rapidamente o desempenho da estratégia durante a otimização e depuração da estratégia.

Objetivo:

• Exiba informações importantes da operação da estratégia em tempo hábil para facilitar o monitoramento do usuário.
• Fornece um mecanismo de feedback para mostrar se a transação foi executada com sucesso ou se houve algum erro.

# 更新状态函数
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  # 更新收益时间

Lógica de Transação

O principal processo de tomada de decisão em negociações. Com base em dados de mercado, informações de contas e posições, combinados com indicadores técnicos ou modelos quantitativos, são tomadas decisões sobre comprar, vender, aumentar ou diminuir posições. A lógica de negociação varia de acordo com a estratégia, como estratégias de acompanhamento de tendências, reversão à média ou rompimento.

Objetivo:

• Tome decisões de negociação inteligentes com base em dados de mercado e status da conta.
• Lidar com diversas situações de mercado e garantir que as estratégias possam operar razoavelmente em diferentes ambientes de mercado.

Para demonstrar a aplicabilidade da estrutura, a estratégia de negociação neste artigo utiliza uma lógica simples. Cada ordem é fixada em 50 USDT e, após a execução da negociação, a quantidade de compra ou venda correspondente é calculada com base nos preços de compra e venda atuais do mercado. As regras de execução desta estratégia são muito básicas e visam demonstrar como aplicar a estrutura da estratégia de negociação de futuros multimoedas em um ambiente de negociação real. Para garantir simplicidade e operabilidade, uma condição de parada é definida: quando o valor total de posições em aberto de um par de negociação atinge 2.000 USDT, as ordens subsequentes cessam. Isso nos permite demonstrar convenientemente a estrutura básica da estratégia e como a estrutura interage com os dados de mercado das bolsas.

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)  # 执行买入操作

Circuito principal

O loop principal é o núcleo da estrutura da estratégia, responsável por garantir o desempenho consistente e estável da estratégia no mercado. Ele realiza regularmente diversas operações em intervalos definidos, como obter os dados de mercado mais recentes, atualizar informações de posição e executar decisões de negociação. Por meio do loop principal, a estratégia pode responder às mudanças do mercado em tempo real e garantir que cada execução seja baseada nos dados de mercado mais recentes. Normalmente, o loop principal é acionado uma vez a cada novo período de tempo (como a cada minuto, a cada hora ou quando um novo candlestick é gerado).

Objetivo:

• Garanta a operação contínua e estável da estratégia, obtenha dados de mercado em tempo real e tome decisões de negociação.
• Cada ciclo garante a execução da estratégia em tempo real e com precisão.

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)

Explicação do código:

1. OnTickfunçãoEsta função é a tarefa principal executada sempre dentro do loop principal. Ela é responsável por atualizar informações de mercado, informações de posição, executar negociações e atualizar o status da estratégia. Todas as negociações e atualizações de informações são realizadas dentro desta função. Quaisquer erros durante a execução são capturados e registrados.

2. mainfunção：A função principal inicializa as informações relevantes, define a estação base de troca e inicia um loop infinito. Em cada loop, o programa verifica se o intervalo de tempo definido passou. Em caso afirmativo,OnTickA função será chamada para executar a estratégia. Se o intervalo de tempo ainda não tiver chegado, o programa aguardará e continuará o loop para garantir que a estratégia seja executada de acordo com o intervalo de tempo predeterminado.

3. Controle de atraso: Após cada loop, o programa pausa por 5 milissegundos para reduzir a carga da CPU. Isso evita o consumo excessivo de recursos computacionais devido a loops de alta frequência.

Lógica de operação

• Fase de inicialização: Primeiro defina a API e outros parâmetros necessários, depois inicialize as informações e obtenha a precisão da moeda.
• Fase do loop principal：Entre em um loop infinito, cada loop verificará o intervalo de tempo para garantir que o intervalo de tempo para execução da política atenda às configurações predefinidas.
• Fase de execução：Após a condição de intervalo de tempo ser atendida,OnTickA função será chamada para executar todas as operações de estratégia, incluindo atualizações de informações de mercado, execução de negociações, etc.

Este design de loop principal garante que a estratégia continue a ser executada em condições de mercado em tempo real e tome decisões de negociação oportunas, melhorando assim a estabilidade e a precisão da estratégia.

Resumir

Esta estrutura estratégica foi projetada com modularidade e escalabilidade em mente. Cada etapa tem responsabilidades claras, garantindo robustez e facilitando futuras expansões e otimizações. Ao utilizar APIs de corretoras, as estratégias podem ser simplificadas e mais consistentes com backtesting e negociação em tempo real.

precisarPerceberObserve que esta estrutura de demonstração utiliza a corretora simulada Binance como exemplo, com o objetivo de fornecer uma estrutura básica para o desenvolvimento e a operação da estratégia. Na prática, a otimização baseada na lógica da estratégia real será necessária, como o ajuste dinâmico de parâmetros com base nas condições de mercado, a otimização de mecanismos de controle de risco e a adição de tratamento de exceções. Além disso, devido às diferenças nas interfaces de API, regras de negociação, configurações de precisão e estruturas de taxas entre as corretoras, a otimização e a adaptação detalhadas com base nos requisitos específicos da corretora alvo serão necessárias na implementação real para garantir a estabilidade e a compatibilidade da estratégia. Recomenda-se que você teste e verifique completamente a confiabilidade e o desempenho da sua estratégia antes de implementá-la em negociações no mundo real.

apêndice：Endereço da estrutura multimoeda Python