Criação de classes Python para trading no MetaTrader 5, análogas às apresentadas em MQL5

MetaTrader 5 — Sistemas de negociação | 28 abril 2026, 15:18

Omega J Msigwa

Conteúdo

Introdução

A criação de sistemas de trading algorítmico na linguagem de programação MQL5 ficou mais simples graças às bibliotecas padrão já incluídas no editor MetaEditor. Esses módulos (bibliotecas) contêm funções e variáveis que simplificam a abertura, a confirmação e o fechamento de operações etc.

Sem essas dependências, escrever até mesmo um programa simples se torna mais complexo, ainda que seja apenas um script simples para abrir uma posição (operação) de compra.

Sem a classe CTrade

void OnStart()
  {
   MqlTradeRequest request;
   MqlTradeResult result;
   
   MqlTick ticks;
   SymbolInfoTick(Symbol(), ticks);
   
//--- setting a trade request
   
   ZeroMemory(request);
   request.action   =TRADE_ACTION_DEAL;
   request.symbol   =Symbol();
   request.magic    =2025;
   request.volume   =0.01;
   request.type     =ORDER_TYPE_BUY;
   request.price    =ticks.ask;
   request.sl       =0;
   request.tp       =0;
   request.deviation   = 10;  // Max price slippage in points
   request.magic       = 2025;
   request.comment     = "Buy Order";
   request.type_filling= ORDER_FILLING_IOC;   // or ORDER_FILLING_IOC, ORDER_FILLING_RETURN
   request.type_time   = ORDER_TIME_GTC;      // Good till canceled
   
//--- action and return the result

   if(!OrderSend(request, result))
    {
      Print("OrderSend failed retcode: ", result.retcode);
    }
  }

Com a classe CTrade

#include <Trade\Trade.mqh>
CTrade m_trade;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
    MqlTick ticks;
    SymbolInfoTick(Symbol(), ticks);
    
    m_trade.SetTypeFillingBySymbol(Symbol());
    m_trade.SetExpertMagicNumber(2025);
    m_trade.SetDeviationInPoints(10); //Slippage 
    
    m_trade.Buy(0.01, Symbol(), ticks.ask,0,0,"Buy Order");
  }

Ambas as funções abrem uma posição de compra no MetaTrader 5, porém a primeira abordagem é extremamente primitiva, consome tempo e aumenta a probabilidade de erros devido à necessidade de escrever muitas linhas de código para obter a funcionalidade mais básica.

Sem mencionar que ela exige conhecimentos técnicos mais aprofundados para entender tudo o que envolve a abertura de uma posição de compra no MetaTrader 5.

Existe um pacote Python conhecido como MetaTrader 5, que dá aos desenvolvedores Python acesso à plataforma, a possibilidade de obter quase todas as informações da plataforma (símbolos, posições abertas etc.), bem como enviar alguns comandos para abrir, modificar, excluir operações e assim por diante. Ele oferece um conjunto de funcionalidades análogo ao apresentado na linguagem de programação MQL5.

Apesar de toda a utilidade desse pacote, ele não possui módulos integrados semelhantes aos existentes na linguagem MQL5 e que nos auxiliam no desenvolvimento.

Seguindo a lógica do código do primeiro exemplo, para escrever um programa simples em Python, você precisará escrever mais linhas de código e, o que é ainda pior, esse pacote Python MetaTrader5 não se integra muito bem à maioria dos ambientes de desenvolvimento integrado (IDEs), como o Visual Studio Code. Consequentemente, você não poderá aproveitar o recurso IntelliSense de autocompletar código, que pode ser extremamente útil.

Como a IDE não oferece suporte adequado ao IntelliSense para esse pacote, você terá de consultar a documentação com frequência para esclarecer conceitos simples que esqueceu, em vez de verificá-los diretamente na IDE. Como resultado, usar esse pacote se transforma em um verdadeiro pesadelo.

Neste artigo, implementaremos classes de trading em Python construídas sobre o pacote MetaTrader5, que nos ajudarão a escrever programas em Python com a mesma eficiência que em MQL5.

Classe CAccountInfo

Na linguagem MQL5, essa classe serve para acessar as propriedades da conta de negociação. Com essa classe, é possível obter todas as informações sobre a conta de negociação na corretora. Vamos implementar seu equivalente em Python.

Classe de trading CAccountInfo em Python	Classe de trading CAccountInfo incorporada ao MQL5	Descrição
Propriedades dos tipos Integer e String
login()	Login	Obtém o número da conta.
trade_mode()	TradeMode	Obtém o modo de trading.
trade_mode_description()	TradeModeDescription	Obtém o modo de trading em formato de string.
leverage()	Leverage	Obtém o valor da alavancagem definida.
stopout_mode()	StopoutMode	Obtém o modo de cálculo do Stop Out.
stopout_mode_description()	StopoutModeDescription	Obtém o modo de cálculo do Stop Out em formato de string.
margin_mode()	MarginMode	Obtém o modo de cálculo da margem.
margin_mode_description()	MarginModeDescription	Obtém o modo de cálculo da margem em formato de string.
trade_allowed()	TradeAllowed	Obtém o flag de permissão de trading.
trade_expert()	TradeExpert	Obtém o flag de permissão para trading automático.
limit_orders()	LimitOrders	Obtém a quantidade máxima permitida de ordens pendentes.
Propriedades do tipo Double
balance()	Balance	Obtém o saldo da conta MetaTrader 5.
credit()	Credit	Obtém o valor do crédito concedido.
profit()	Profit	Obtém o valor atual do lucro na conta.
equity()	Equity	Obtém o valor atual dos fundos próprios na conta.
margin()	Margin	Obtém o valor da margem reservada.
free_margin()	FreeMargin	Obtém o valor da margem livre.
margin_level()	MarginLevel	Obtém o nível de margem.
margin_call()	MarginCall	Obtém o nível da chamada de margem.
margin_stopout()	MarginStopOut	Obtém o nível de margem no qual ocorre o fechamento compulsório da posição mais deficitária (Stop Out).
Propriedades do tipo Text
name()	Name	Obtém o nome da conta.
server()	Server	Obtém o nome do servidor de trading.
company()	Company	Obtém o nome da empresa responsável pela conta.
currency()	Currency	Obtém o nome da moeda do depósito.
Métodos adicionais
margin_check(self, symbol, order_type, volume, price)	MarginCheck	Obtém o valor da margem exigida para executar uma operação de trading.
free_margin_check(self, symbol, order_type, volume, price)	FreeMarginCheck	Obtém o valor da margem livre restante após a execução de uma operação de trading.
order_profit_check(self, symbol, order_type, volume, price_open, price_close)	OrderProfitCheck	Obtém o lucro estimado com base nos parâmetros passados.
max_lot_check(self, symbol, order_type, price, percent=100)	MaxLotCheck	Obtém o volume máximo possível da operação de trading.

Exemplo de uso

import MetaTrader5 as mt5
from Trade.AccountInfo import CAccountInfo

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()

acc = CAccountInfo()

print(f"""
Account Information
-------------------
Login: {acc.login()}
Name: {acc.name()}
Server: {acc.server()}
Company: {acc.company()}
Currency: {acc.currency()}
Trade Mode: {acc.trade_mode()} ({acc.trade_mode_description()})
Leverage: {acc.leverage()}
Stopout Mode: {acc.stopout_mode()} ({acc.stopout_mode_description()})
Margin Mode: {acc.margin_mode()} ({acc.margin_mode_description()})
Trade Allowed: {acc.trade_allowed()}
Trade Expert: {acc.trade_expert()}
Limit Orders: {acc.limit_orders()}
-------------------
Balance: {acc.balance()}
Credit: {acc.credit()}
Profit: {acc.profit()}
Equity: {acc.equity()}
Margin: {acc.margin()}
Free Margin: {acc.free_margin()}
Margin Level: {acc.margin_level()}
Margin Call: {acc.margin_call()}
Margin StopOut: {acc.margin_stopout()}
-------------------
""")

mt5.shutdown()

Saída

Account Information
-------------------
Login: 61346344
Name: John Doe      
Server: MetaQuotes-Demo
Company: MetaQuotes Software Corp
Currency: USD
Trade Mode: 0 (Demo)
Leverage: 400
Stopout Mode: 0 (Percent)
Margin Mode: 2 (Retail Hedging)   
Trade Allowed: True
Trade Expert: True
Limit Orders: 500
-------------------
Balance: 928.42
Credit: 0.0
Profit: -2.21
Equity: 926.21
Margin: 2.81
Free Margin: 923.4
Margin Level: 32961.20996441281
Margin Call: 90.0
Margin StopOut: 20.0
-------------------

Classe CSymbolInfo

Essa classe fornece acesso às propriedades dos símbolos.

Classe CSymbolInfo em Python	Classe CSymbolInfo integrada ao MQL5	Descrição
Gerenciamento
refresh()	Refresh	Atualiza os dados do símbolo.
refresh_rates()	RefreshRates	Atualiza as cotações do símbolo.
Propriedades
name()	Name	Obtém o nome do símbolo.
select(self, select=True)	Select	Adiciona o símbolo à janela "Market Watch" ou o remove dela.
is_synchronized()	IsSynchronized	Verifica se o símbolo está sincronizado com o servidor.
Volumes
volume()	Volume	Obtém o volume do último negócio.
volume_high()	VolumeHigh	Obtém o volume máximo do dia.
volume_low()	VolumeLow	Obtém o volume mínimo do dia.
Outros
time()	Time	Obtém o horário da última cotação.
spread()	Spread	Obtém o tamanho do spread (em pontos).
spread_float()	SpreadFloat	Obtém o flag de spread flutuante.
ticks_book_depth()	TicksBookDepth	Obtém a profundidade do histórico de ticks.
Níveis
stops_level()	StopsLevel	Obtém a distância mínima para ordens (em pontos).
freeze_level()	FreezeLevel	Obtém o nível de congelamento das operações de trading (em pontos).
Preços Bid
bid()	Bid	Obtém o preço Bid atual.
bid_high()	BidHigh	Obtém o preço Bid máximo do dia.
bid_low()	BidLow	Obtém o preço Bid mínimo do dia.
Preços Ask
ask()	Ask	Obtém o preço Ask atual.
ask_high()	AskHigh	Obtém o preço Ask máximo do dia.
ask_low()	AskLow	Obtém o preço Ask mínimo do dia.
Preços
last()	Last	Retorna o preço Last atual.
last_high()	LastHigh	Retorna o preço Last máximo do dia.
last_low()	LastLow	Retorna o preço Last mínimo do dia.
Modos de trading
trade_calc_mode()	TradeCalcMode	Obtém o modo de cálculo do valor dos contratos em formato inteiro.
trade_calc_mode_description()	TradeCalcModeDescription	Obtém o modo de cálculo do valor dos contratos como string.
trade_mode()	TradeMode	Obtém o tipo de execução de ordens em formato inteiro.
trade_mode_description()	TradeModeDescription	Obtém o tipo de execução de ordens como string.
trade_execution()	TradeExecution	Obtém o modo de execução de negócios em formato inteiro.
trade_execution_description()	TradeExecutionDescription	Obtém o modo de execução de negócios como string.
Swaps
swap_mode()	SwapMode	Obtém o modo de cálculo do swap em formato inteiro.
swap_mode_description()	SwapModeDescription	Obtém o modo de cálculo do swap como string.
swap_rollover_3days()	SwapRollover3days	Obtém o dia de aplicação do swap triplo como número inteiro.
swap_rollover_3days_description()	SwapRollover3daysDescription	Obtém o dia de aplicação do swap triplo como string.
Margem
margin_initial()	MarginInitial	Obtém o nível da margem inicial.
margin_maintenance()	MarginMaintenance	Obtém o valor da margem de manutenção.
margin_hedged()		Retorna o valor da margem hedgeada para o símbolo especificado.
margin_hedged_use_leg()		Retorna um valor booleano que informa se a margem hedgeada é aplicada separadamente a cada lado da posição.
Informações sobre ticks
digits()	Digits	Obtém o número de casas decimais.
point()	Point	Obtém o valor de um ponto.
tick_value()	TickValue	Obtém o valor do tick (variação mínima de preço).
tick_value_profit()	TickValueProfit	Obtém o valor calculado do tick para uma posição lucrativa.
tick_value_loss()	TickValueLoss	Obtém o valor calculado do tick para uma posição com prejuízo.
tick_size()	TickSize	Obtém a variação mínima de preço.
Tamanhos dos contratos
contract_size()	ContractSize	Obtém o tamanho do contrato de trading.
lots_min()	LotsMin	Obtém o volume mínimo de um negócio.
lots_max()	LotsMax	Obtém o volume máximo de um negócio.
lots_step()	LotsStep	Obtém o incremento mínimo do volume de um negócio.
lots_limit()	LotsLimit	Obtém o volume máximo permitido de uma posição aberta e de ordens pendentes em qualquer direção em um mesmo símbolo.
Valores dos swaps
swap_long()	SwapLong	Obtém o valor do swap para posição longa.
swap_short()	SwapShort	Obtém o valor do swap para posição curta.
Informações sobre símbolo/moeda
currency_base()	CurrencyBase	Obtém o nome da moeda base do símbolo.
currency_profit()	CurrencyProfit	Obtém o nome da moeda de cálculo do lucro.
currency_margin()	CurrencyMargin	Obtém o nome da moeda da margem.
bank()	Bank	Obtém o nome do feed atual de cotações.
description()	Description	Obtém a descrição textual do símbolo.
path()	Path	Obtém o caminho na árvore de símbolos.
page()		URL da página que contém informações sobre o símbolo.
Informações sobre a sessão
session_deals()	SessionDeals	Obtém a quantidade de negócios na sessão atual.
session_buy_orders()	SessionBuyOrders	Obtém a quantidade de ordens de compra no momento atual.
session_sell_orders()	SessionSellOrders	Obtém a quantidade de ordens de venda no momento atual.
session_turnover()	SessionTurnover	Obtém o volume negociado total da sessão atual.
session_interest()	SessionInterest	Obtém o open interest total da sessão atual.
session_buy_orders_volume()	SessionBuyOrdersVolume	Obtém o volume das ordens de compra.
session_sell_orders_volume()	SessionSellOrdersVolume	Obtém o volume das ordens de venda.
session_open()	SessionOpen	Obtém o preço de abertura da sessão atual.
session_close()	SessionClose	Obtém o preço de fechamento da sessão atual.
session_aw()	SessionAW	Obtém o preço médio ponderado da sessão atual.
session_price_settlement()	SessionPriceSettlement	Obtém o preço de ajuste da sessão atual.
session_price_limit_min()	SessionPriceLimitMin	Obtém o limite mínimo de preço da sessão atual.
session_price_limit_max()	SessionPriceLimitMax	Obtém o limite máximo de preço da sessão atual.

Estes são apenas alguns dos métodos desta classe Python (veja a lista completa no arquivo SymbolInfo.py).

Exemplo de uso

import MetaTrader5 as mt5
from Trade.SymbolInfo import CSymbolInfo


if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()
      
m_symbol = CSymbolInfo("EURUSD")

print(f"""
Symbol Information
---------------------
Name: {m_symbol.name()}
Selected: {m_symbol.select()}
Synchronized: {m_symbol.is_synchronized()}

--- Volumes ---
Volume: {m_symbol.volume()}
Volume High: {m_symbol.volume_high()}
Volume Low: {m_symbol.volume_low()}

--- Time & Spread ---
Time: {m_symbol.time()}
Spread: {m_symbol.spread()}
Spread Float: {m_symbol.spread_float()}
Ticks Book Depth: {m_symbol.ticks_book_depth()}

--- Trade Levels ---
Stops Level: {m_symbol.stops_level()}
Freeze Level: {m_symbol.freeze_level()}

--- Bid Parameters ---
Bid: {m_symbol.bid()}
Bid High: {m_symbol.bid_high()}
Bid Low: {m_symbol.bid_low()}

--- Ask Parameters ---
Ask: {m_symbol.ask()}
Ask High: {m_symbol.ask_high()}
Ask Low: {m_symbol.ask_low()}

--- Last Parameters ---
Last: {m_symbol.last()}
Last High: {m_symbol.last_high()}
Last Low: {m_symbol.last_low()}

--- Order & Trade Modes ---
Trade Calc Mode: {m_symbol.trade_calc_mode()} ({m_symbol.trade_calc_mode_description()})
Trade Mode: {m_symbol.trade_mode()} ({m_symbol.trade_mode_description()})
Trade Execution Mode: {m_symbol.trade_execution()}  ({m_symbol.trade_execution_description()})

--- Swap Terms ---
Swap Mode: {m_symbol.swap_mode()} ({m_symbol.swap_mode_description()})
Swap Rollover 3 Days: {m_symbol.swap_rollover_3days()} ({m_symbol.swap_rollover_3days_description()})

--- Futures Dates ---
Start Time: {m_symbol.start_time()}
Expiration Time: {m_symbol.expiration_time()}

--- Margin Parameters ---
Initial Margin: {m_symbol.margin_initial()}
Maintenance Margin: {m_symbol.margin_maintenance()}
Hedged Margin: {m_symbol.margin_hedged()}
Hedged Margin Use Leg: {m_symbol.margin_hedged_use_leg()}

--- Tick Info ---

Digits: {m_symbol.digits()}
Point: {m_symbol.point()}
Tick Value: {m_symbol.tick_value()}
Tick Value Profit: {m_symbol.tick_value_profit()}
Tick Value Loss: {m_symbol.tick_value_loss()}
Tick Size: {m_symbol.tick_size()}

--- Contracts sizes---
Contract Size: {m_symbol.contract_size()}
Lots Min: {m_symbol.lots_min()}
Lots Max: {m_symbol.lots_max()}
Lots Step: {m_symbol.lots_step()}
Lots Limit: {m_symbol.lots_limit()}

--- Swap sizes 

Swap Long: {m_symbol.swap_long()}
Swap Short: {m_symbol.swap_short()}

--- Currency Info ---
Currency Base: {m_symbol.currency_base()}
Currency Profit: {m_symbol.currency_profit()}
Currency Margin: {m_symbol.currency_margin()}
Bank: {m_symbol.bank()}
Description: {m_symbol.description()}
Path: {m_symbol.path()}
Page: {m_symbol.page()}

--- Session Info ---
Session Deals: {m_symbol.session_deals()}
Session Buy Orders: {m_symbol.session_buy_orders()}
Session Sell Orders: {m_symbol.session_sell_orders()}
Session Turnover: {m_symbol.session_turnover()}
Session Interest: {m_symbol.session_interest()}
Session Buy Volume: {m_symbol.session_buy_orders_volume()}
Session Sell Volume: {m_symbol.session_sell_orders_volume()}
Session Open: {m_symbol.session_open()}
Session Close: {m_symbol.session_close()}
Session AW: {m_symbol.session_aw()}
Session Price Settlement: {m_symbol.session_price_settlement()}
Session Price Limit Min: {m_symbol.session_price_limit_min()}
Session Price Limit Max: {m_symbol.session_price_limit_max()}
---------------------
""")

mt5.shutdown()

Saída

Symbol Information       
---------------------    
Name: EURUSD
Selected: True
Synchronized: True       

--- Volumes ---
Volume: 0
Volume High: 0
Volume Low: 0

--- Time & Spread ---    
Time: 2025-05-21 20:30:36
Spread: 0
Spread Float: True       
Ticks Book Depth: 0      

--- Trade Levels ---     
Stops Level: 0
Freeze Level: 0

--- Bid Parameters ---
Bid: 1.1335600000000001
Bid High: 1.13623
Bid Low: 1.12784

--- Ask Parameters ---
Ask: 1.1335600000000001
Ask High: 1.13623
Ask Low: 1.12805

--- Last Parameters ---
Last: 0.0
Last High: 0.0
Last Low: 0.0

--- Order & Trade Modes ---
Trade Calc Mode: 0 (Calculation of profit and margin for Forex)
Trade Mode: 4 (No trade restrictions)
Trade Execution Mode: 2  (Market execution)

--- Swap Terms ---
Swap Mode: 1 (Swaps are calculated in points)
Swap Rollover 3 Days: 3 (Wednesday)

--- Futures Dates ---
Start Time: 0
Expiration Time: 0

--- Margin Parameters ---
Initial Margin: 100000.0
Maintenance Margin: 0.0
Hedged Margin: 0.0
Hedged Margin Use Leg: False

--- Tick Info ---

Digits: 5
Point: 1e-05
Tick Value: 1.0
Tick Value Profit: 1.0
Tick Value Loss: 1.0
Tick Size: 1e-05

--- Contracts sizes---
Contract Size: 100000.0
Lots Min: 0.01
Lots Max: 100.0
Lots Step: 0.01
Lots Limit: 0.0

--- Swap sizes

Swap Long: -8.99
Swap Short: 4.5

--- Currency Info ---
Currency Base: EUR
Currency Profit: USD
Currency Margin: EUR
Bank: Pepperstone
Description: Euro vs US Dollar
Path: Markets\Forex\Majors\EURUSD
Page:

--- Session Info ---
Session Deals: 1
Session Buy Orders: 647
Session Sell Orders: 2
Session Turnover: 10.0
Session Interest: 0.0
Session Buy Volume: 3.0
Session Sell Volume: 13.0
Session Open: 1.12817
Session Close: 1.12842
Session AW: 0.0
Session Price Settlement: 0.0
Session Price Limit Min: 0.0
Session Price Limit Max: 0.0
---------------------

Classe COrderInfo

Essa classe fornece acesso às propriedades das ordens pendentes.

Classe COrderInfo em Python	Classe COrderInfo incorporada ao MQL5	Descrição
Propriedades dos tipos Integer e Datetime
ticket()	Ticket	Obtém o ticket da ordem previamente selecionada para acesso.
type_time()	TypeTime	Obtém o tipo de validade da ordem.
type_time_description()	TypeTimeDescription	Obtém o tipo de validade da ordem como string.
time_setup()	TimeSetup	Obtém o horário de envio da ordem.
time_setup_msc()	TimeSetupMsc	Obtém o horário de colocação da ordem em milissegundos a partir de 01.01.1970.
order_type()	OrderType	Obtém o tipo da ordem em formato inteiro.
order_type_description()	OrderTypeDescription	Obtém o tipo da ordem como string.
state()	State	Obtém o estado da ordem como número inteiro.
state_description()	StateDescription	Obtém o estado da ordem como string.
magic()	Magic	Obtém o identificador do EA que colocou a ordem.
position_id()	PositionId	Obtém o identificador da posição.
type_filling()	TypeFilling	Obtém a política de preenchimento da ordem quanto ao volume restante como número inteiro.
type_filling_description()	TypeFillingDescription	Obtém a política de preenchimento da ordem quanto ao volume restante como string.
time_done()	TimeDone	Obtém o horário de execução ou cancelamento da ordem.
time_done_msc()	TimeDoneMsc	Obtém o horário de execução ou cancelamento da ordem em milissegundos a partir de 01.01.1970.
time_expiration()	TimeExpiration	Obtém o horário de expiração da ordem.
Propriedades do tipo Double
volume_initial()	VolumeInitial	Obtém o volume inicial da ordem.
volume_current()	VolumeCurrent	Obtém o volume não executado da ordem.
price_open()	PriceOpen	Obtém o preço da ordem.
price_current()	PriceCurrent	Obtém o preço atual do símbolo da ordem.
stop_loss()	StopLoss	Obtém o nível de Stop Loss da ordem.
take_profit()	TakeProfit	Obtém o nível de Take Profit da ordem.
price_stop_limit()	PriceStopLimit	Obtém o preço da ordem limite.
Acesso às propriedades de texto
comment()	Symbol	Obtém o nome do símbolo da ordem.
symbol()	Comment	Obtém o comentário da ordem.
Seleção
select_order(self, order) -> bool		Seleciona uma ordem pelo seu objeto (dicionário) a partir da lista de ordens retornada pela função MetaTrader5.orders_get().

Exemplo de uso

import MetaTrader5 as mt5
from Trade.OrderInfo import COrderInfo

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()
      
# Get all orders from MT5
orders = mt5.orders_get()

# Loop and print info
m_order = COrderInfo()

for i, order in enumerate(orders):
    if m_order.select_order(order=order):
        print(f"""
Order #{i}

--- Integer & datetime type properties ---

Ticket: {m_order.ticket()}
Type Time: {m_order.type_time()} ({m_order.type_time_description()})
Time Setup: {m_order.time_setup()}
Time Setup (ms): {m_order.time_setup_msc()}
State: {m_order.state()} ({m_order.state_description()})
Order Type: {m_order.order_type()} ({m_order.order_type_description()})
Magic Number: {m_order.magic()}
Position ID: {m_order.position_id()}
Type Filling: {m_order.type_filling()} ({m_order.type_filling_description()})
Time Done: {m_order.time_done()}
Time Done (ms): {m_order.time_done_msc()}
Time Expiration: {m_order.time_expiration()}
External ID: {m_order.external_id()}

--- Double type properties ---

Volume Initial: {m_order.volume_initial()}
Volume Current: {m_order.volume_current()}
Price Open: {m_order.price_open()}
Price Current: {m_order.price_current()}
Stop Loss: {m_order.stop_loss()}
Take Profit: {m_order.take_profit()}
Price StopLimit: {m_order.price_stop_limit()}

--- Text type properties ---

Comment: {m_order.comment()}
Symbol: {m_order.symbol()}

""")

mt5.shutdown()

Saída

Order #0

--- Integer & datetime type properties --- 

Ticket: 153201235
Type Time: 2 (ORDER_TIME_SPECIFIED)        
Time Setup: 2025-05-21 23:56:16
Time Setup (ms): 1747860976672
State: 1 (Order accepted)
Order Type: 3 (Sell Limit pending order)   
Magic Number: 1001
Position ID: 0
Type Filling: 2 (IOC (Immediate or Cancel))
Time Done: 1970-01-01 03:00:00
Time Done (ms): 0
Time Expiration: 2025-05-21 23:57:14.940000
External ID:

--- Double type properties ---

Volume Initial: 0.01
Volume Current: 0.01
Price Open: 1.13594
Price Current: 1.1324
Stop Loss: 0.0
Take Profit: 0.0
Price StopLimit: 0.0

--- Text type properties ---

Comment: Sell Limit Order
Symbol: EURUSD

Classe CHistoryOrderInfo

Essa classe fornece acesso simples às propriedades do histórico de ordens.

Classe CHistoryOrderInfo em Python	Classe CHistoryOrderInfo incorporada ao MQL5	Descrição
Propriedades dos tipos Integer, Datetime e String
time_setup()	TimeSetup	Obtém o horário de envio da ordem.
time_setup_msc()	TimeSetupMsc	Retorna o horário de colocação da ordem em milissegundos a partir de 01.01.1970.
time_done()	TimeDone	Obtém o horário de execução ou cancelamento da ordem.
time_done_msc()	TimeDoneMsc	Retorna o horário de execução ou cancelamento da ordem em milissegundos a partir de 01.01.1970.
magic()	Magic	Obtém o identificador do EA que colocou a ordem selecionada.
ticket()		Retorna o ticket da ordem selecionada.
order_type()	OrderType	Retorna o tipo da ordem selecionada.
order_type_description()	OrderTypeDescription	Retorna o tipo da ordem selecionada como string.
state()	State	Retorna o estado da ordem como número inteiro.
state_description()	StateDescription	Retorna o estado da ordem como string.
time_expiration()	TimeExpiration	Obtém o horário de expiração da ordem selecionada.
type_filling()	TypeFilling	Obtém a política de preenchimento da ordem quanto ao volume restante em formato inteiro.
type_filling_description()	TypeFillingDescription	Obtém a política de preenchimento da ordem quanto ao volume restante como string.
type_time()	TypeTime	Obtém o tipo de validade da ordem selecionada em formato inteiro.
type_time_description()	TypeTimeDescription	Obtém o tipo de validade da ordem selecionada como string.
position_id()	PositionId	Obtém o identificador da posição.
Propriedades do tipo Double
volume_initial()	VolumeInitial	Obtém o volume inicial da ordem selecionada.
volume_current()	VolumeCurrent	Obtém o volume remanescente da ordem selecionada.
price_open()	PriceOpen	Obtém o preço da ordem selecionada.
price_current()	PriceCurrent	Obtém o preço atual do símbolo da ordem.
stop_loss()	StopLoss	Obtém o nível de Stop Loss da ordem selecionada.
take_profit()	TakeProfit	Obtém o nível de Take Profit da ordem selecionada.
price_stop_limit()	PriceStopLimit	Obtém o preço da ordem limite selecionada.
Propriedades de texto
symbol()	Symbol	Retorna o símbolo da ordem selecionada.
comment()	Comment	Retorna o comentário da ordem selecionada.
Seleção
select_order(self, order) -> bool		Seleciona uma ordem pelo objeto correspondente a partir da lista de objetos (dicionários) retornada pela função MetaTrader5.history_orders_get.

Exemplo de uso

import MetaTrader5 as mt5
from Trade.HistoryOrderInfo import CHistoryOrderInfo
from datetime import datetime, timedelta

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()

# The date range

from_date = datetime.now() - timedelta(hours=5)
to_date = datetime.now()

# Get history orders

history_orders = mt5.history_orders_get(from_date, to_date)

if history_orders == None:
    print(f"No deals, error code={mt5.last_error()}")
    exit()
    
# m_order instance
m_order = CHistoryOrderInfo()

# Loop and print each order
for i, order in enumerate(history_orders):
    if m_order.select_order(order):
        print(f"""
History Order #{i}

--- Integer, Datetime & String type properties ---

Time Setup: {m_order.time_setup()}
Time Setup (ms): {m_order.time_setup_msc()}
Time Done: {m_order.time_done()}
Time Done (ms): {m_order.time_done_msc()}
Magic Number: {m_order.magic()}
Ticket: {m_order.ticket()}
Order Type: {m_order.order_type()} ({m_order.type_description()})
Order State: {m_order.state()} ({m_order.state_description()})
Expiration Time: {m_order.time_expiration()}
Filling Type: {m_order.type_filling()} ({m_order.type_filling_description()})
Time Type: {m_order.type_time()} ({m_order.type_time_description()})
Position ID: {m_order.position_id()}
Position By ID: {m_order.position_by_id()}

--- Double type properties ---

Volume Initial: {m_order.volume_initial()}
Volume Current: {m_order.volume_current()}
Price Open: {m_order.price_open()}
Price Current: {m_order.price_current()}
Stop Loss: {m_order.stop_loss()}
Take Profit: {m_order.take_profit()}
Price Stop Limit: {m_order.price_stop_limit()}

--- Access to text properties ---

Symbol: {m_order.symbol()}
Comment: {m_order.comment()}
""")

mt5.shutdown()

Saída

History Order #79

--- Integer, Datetime & String type properties ---

Time Setup: 2025-05-21 23:56:17
Time Setup (ms): 1747860977335
Time Done: 2025-05-22 01:57:47
Time Done (ms): 1747868267618
Magic Number: 1001
Ticket: 153201241
Order Type: 5 (Sell Stop pending order)
Order State: 4 (Order fully executed)
Expiration Time: 2025-05-21 23:57:14.940000
Filling Type: 1 (FOK (Fill or Kill))
Time Type: 2 (ORDER_TIME_SPECIFIED)
Position ID: 153201241
Position By ID: 0

--- Double type properties ---

Volume Initial: 0.01
Volume Current: 0.0
Price Open: 1.13194
Price Current: 1.13194
Stop Loss: 0.0
Take Profit: 0.0
Price Stop Limit: 0.0

--- Access to text properties ---

Symbol: EURUSD
Comment: Sell Stop Order

Classe CPositionInfo

Essa classe fornece acesso simples às propriedades das posições abertas.

Classe CPositionInfo em Python	Classe CPositionInfo incorporada ao MQL5	Descrição
Propriedades dos tipos Integer e Datetime
ticket()		Obtém o ticket da posição previamente selecionada para acesso.
time()	Time	Obtém o horário de abertura da posição.
time_msc()	TimeMsc	Obtém o horário de abertura da posição em milissegundos a partir de 01.01.1970.
time_update()	TimeUpdate	Obtém o horário de atualização da posição em segundos a partir de 01.01.1970.
time_update_msc()	TimeUpdateMsc	Obtém o horário de atualização da posição em milissegundos a partir de 01.01.1970.
position_type()	PositionType	Obtém o tipo da posição como número inteiro.
position_type_description()	TypeDescription	Obtém o tipo da posição como string.
magic()	Magic	Obtém o identificador do EA que abriu a posição.
position_id()	Identifier	Obtém o identificador da posição.
Propriedades do tipo Double
volume()	Volume	Obtém o volume da posição.
price_open()	PriceOpen	Obtém o preço de abertura da posição.
stop_loss()	StopLoss	Obtém o preço de Stop Loss da posição.
take_profit()	TakeProfit	Obtém o preço de Take Profit da posição.
price_current()	PriceCurrent	Obtém o preço atual do símbolo da posição.
profit()	Profit	Obtém o valor atual do lucro da posição.
swap()	Swap	Obtém o valor do swap da posição.
Acesso às propriedades de texto
comment()	Comment	Obtém o comentário da posição.
symbol()	Symbol	Obtém o nome do símbolo da posição.
Seleção
select_position(self, position) -> bool		Seleciona o objeto (dicionário) da posição a partir da lista de posições retornada pela função MetaTrader5.positions_get().

Exemplo de uso

import MetaTrader5 as mt5
from Trade.PositionInfo import CPositionInfo

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()
      
positions = mt5.positions_get()
m_position = CPositionInfo()

# Loop and print each position
for i, position in enumerate(positions):
    if m_position.select_position(position):
        print(f"""
Position #{i}

--- Integer type properties ---

Time Open: {m_position.time()}
Time Open (ms): {m_position.time_msc()}
Time Update: {m_position.time_update()}
Time Update (ms): {m_position.time_update_msc()}
Magic Number: {m_position.magic()}
Ticket: {m_position.ticket()}
Position Type: {m_position.position_type()} ({m_position.position_type_description()})

--- Double type properties ---

Volume: {m_position.volume()}
Price Open: {m_position.price_open()}
Price Current: {m_position.price_current()}
Stop Loss: {m_position.stop_loss()}
Take Profit: {m_position.take_profit()}
Profit: {m_position.profit()}
Swap: {m_position.swap()}

--- Access to text properties ---

Symbol: {m_position.symbol()}
Comment: {m_position.comment()}

""")

mt5.shutdown()

Saída

Position #1

--- Integer type properties ---

Time Open: 2025-05-22 15:02:06
Time Open (ms): 1747915326225
Time Update: 2025-05-22 15:02:06
Time Update (ms): 1747915326225
Magic Number: 0
Ticket: 153362497
Position Type: 1 (Sell)

--- Double type properties ---

Volume: 0.1
Price Open: 1.12961
Price Current: 1.1296
Stop Loss: 0.0
Take Profit: 0.0
Profit: 0.1
Swap: 0.0

--- Access to text properties ---

Symbol: EURUSD
Comment:

Classe CDealInfo

Essa classe fornece acesso às propriedades do negócio na plataforma MetaTrader 5.

Classe CDealInfo em Python	Classe CDealInfo incorporada ao MQL5	Descrição
Propriedades dos tipos Integer e Datetime
ticket()		Retorna o ticket do negócio selecionado.
time()	Time	Obtém o horário de execução do negócio.
time_msc()	TimeMsc	Obtém o horário de execução do negócio em milissegundos a partir de 01.01.1970.
deal_type()	DealType	Obtém o tipo do negócio.
type_description()	TypeDescription	Obtém o tipo do negócio como string.
entry()	Entry	Obtém o tipo de entrada/saída do negócio.
entry_description()	EntryDescription	Obtém o tipo de entrada/saída do negócio como string.
magic()	Magic	Obtém o identificador do EA que originou o negócio.
position_id()	PositionId	Obtém o identificador da posição associada ao negócio.
Propriedades do tipo Double
volume()	Volume	Obtém o volume (tamanho do lote) do negócio.
price()	Price	Obtém o preço do negócio.
commission()	Commision	Obtém a comissão do negócio.
swap()	Swap	Obtém o valor do swap no momento do fechamento da posição.
profit()	Profit	Obtém o resultado financeiro do negócio.
Propriedades do tipo String
symbol()	Symbol	Obtém o nome do símbolo do negócio selecionado.
comment()	Comment	Obtém o comentário do negócio selecionado.
Seleção
select_by_index(self, index)		Seleciona um negócio pelo índice.
select_deal(self, deal) -> bool		Seleciona um negócio pelo objeto correspondente (dicionário) a partir da lista de negócios retornada pela função MetaTrader5.history_deals_get.

Exemplo de uso

import MetaTrader5 as mt5
from datetime import datetime, timedelta
from Trade.DealInfo import CDealInfo

# The date range
from_date = datetime.now() - timedelta(hours=24)
to_date = datetime.now()

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()
      
m_deal = CDealInfo()

# Get all deals from MT5 history
deals = mt5.history_deals_get(from_date, to_date)
    
for i, deal in enumerate(deals):
    
    if (m_deal.select_deal(deal=deal)):
        print(f"""
Deal #{i}

--- integer and dateteime properties ---

Ticket: {m_deal.ticket()}
Time: {m_deal.time()}
Time (ms): {m_deal.time_msc()}
Deal Type: {m_deal.deal_type()} ({m_deal.type_description()})
Entry Type: {m_deal.entry()} ({m_deal.entry_description()})
Order: {m_deal.order()}
Magic Number: {m_deal.magic()}
Position ID: {m_deal.position_id()}

--- double type properties ---

Volume: {m_deal.volume()}
Price: {m_deal.price()}
Commission: {m_deal.commission()}
Swap: {m_deal.swap()}
Profit: {m_deal.profit()}

--- string type properties --- 

Comment: {m_deal.comment()}
Symbol: {m_deal.symbol()}

External ID: {m_deal.external_id()}
""")

mt5.shutdown()

Saída

Deal #53

--- integer and dateteime properties ---

Ticket: 0
Time: 2025-05-22 01:57:47
Time (ms): 1747868267618
Deal Type: 1 (SELL)
Entry Type: 0 (IN)
Order: 153201241
Magic Number: 1001
Position ID: 153201241

--- double type properties ---

Volume: 0.01
Price: 1.13194
Commission: -0.04
Swap: 0.0
Profit: 0.0

--- string type properties ---

Comment: Sell Stop Order
Symbol: EURUSD

External ID:

Classe CTerminalInfo

Essa classe fornece acesso às propriedades do ambiente do terminal MetaTrader 5.

Classe CTerminalInfo em Python	Classe CTerminalInfo incorporada ao MQL5	Descrição
Propriedades do tipo String
name()	Name	Obtém o nome do terminal cliente.
company()	Company	Obtém o nome da empresa associada ao terminal cliente.
language()	Language	Obtém o idioma do terminal cliente.
path()	Path	Obtém o diretório do terminal cliente.
data_path()	DataPath	Obtém a pasta de dados do terminal cliente.
common_data_path()	CommonDataPath	Obtém a pasta de dados comum a todos os terminais cliente (todos os aplicativos MetaTrader5 instalados no computador).
Propriedades do tipo Integer
build()	Build	Obtém o número da build do terminal cliente.
is_connected()	IsConnected	Obtém informações sobre a conexão com o servidor de trading.
is_dlls_allowed()	IsDLLsAllowed	Obtém informações sobre a permissão de uso de DLLs.
is_trade_allowed()	IsTradeAllowed	Obtém informações sobre a permissão de trading.
is_email_enabled()	IsEmailEnabled	Obtém informações sobre a permissão para enviar e-mails ao servidor SMTP para o login especificado nas configurações do terminal.
is_ftp_enabled()	IsFtpEnabled	Obtém informações sobre a permissão para enviar relatórios de trading ao servidor FTP para o login especificado nas configurações do terminal.
are_notifications_enabled()		Verifica se as notificações push estão ativadas nas configurações do terminal MetaTrader 5.
is_community_account()		Verifica se o terminal atual está logado na comunidade MetaTrader no site mql5.com.
is_community_connection()		Verifica se o terminal tem uma conexão ativa com os serviços da comunidade MQL5.
is_mqid()		Verifica se o usuário fez login usando seu MQID (MetaQuotes ID).
is_tradeapi_disabled()		Verifica se a Trade API está desativada nas configurações do MetaTrader 5.
max_bars()	MaxBars	Obtém informações sobre a quantidade máxima de barras no gráfico.
code_page()		Retorna um valor inteiro que representa a página de códigos atual (codificação de caracteres) usada pelo terminal MetaTrader 5.
ping_last()		Retorna o último tempo de ping registrado (em microssegundos) entre o terminal MetaTrader e o servidor da corretora.
community_balance()		Retorna o saldo atual da conta do usuário na comunidade MQL5.
retransmission()		Retorna a velocidade de transmissão dos dados do servidor para o terminal.

Exemplo de uso

import MetaTrader5 as mt5
from Trade.TerminalInfo import CTerminalInfo


if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()
      
terminal = CTerminalInfo()

print(f"""
Terminal Information

--- String type ---

Name: {terminal.name()}
Company: {terminal.company()}
Language: {terminal.language()}
Terminal Path: {terminal.path()}
Data Path: {terminal.data_path()}
Common Data Path: {terminal.common_data_path()}

--- Integers type ---

Build: {terminal.build()}
Connected: {terminal.is_connected()}
DLLs Allowed: {terminal.is_dlls_allowed()}
Trade Allowed: {terminal.is_trade_allowed()}
Email Enabled: {terminal.is_email_enabled()}
FTP Enabled: {terminal.is_ftp_enabled()}
Notifications Enabled: {terminal.are_notifications_enabled()}
Community Account: {terminal.is_community_account()}
Community Connected: {terminal.is_community_connection()}
MQID: {terminal.is_mqid()}
Trade API Disabled: {terminal.is_tradeapi_disabled()}
Max Bars: {terminal.max_bars()}
Code Page: {terminal.code_page()}
Ping Last (μs): {terminal.ping_last()}
Community Balance: {terminal.community_balance()}
Retransmission Rate: {terminal.retransmission()}
""")
    
mt5.shutdown()

Saída

Terminal Information

--- String type ---

Name: Pepperstone MetaTrader 5
Company: Pepperstone Group Limited
Language: English
Terminal Path: c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5
Data Path: C:\Users\Omega Joctan\AppData\Roaming\MetaQuotes\Terminal\F4F6C6D7A7155578A6DEA66D12B1D40D
Common Data Path: C:\Users\Omega Joctan\AppData\Roaming\MetaQuotes\Terminal\Common

--- Integers type ---

Build: 4755
Connected: True
DLLs Allowed: True
Trade Allowed: True
Email Enabled: True
FTP Enabled: False
Notifications Enabled: False
Community Account: True
Community Connected: True
MQID: False
Trade API Disabled: False
Max Bars: 100000000
Code Page: 0
Ping Last (μs): 251410
Community Balance: 900.026643
Retransmission Rate: 0.535847326494355

Classe CTrade

Essa classe fornece acesso simples às funções de trading. Ao contrário das classes anteriores, que retornam informações sobre símbolos, sobre o terminal MetaTrader 5, sobre o histórico de negócios e também sobre a conta, esta classe serve para abrir operações.

Definição de parâmetros

Em vez de definir parâmetros como Magic, tipo de execução e valor de desvio em pontos por meio de funções separadas, como é feito na classe CTrade em MQL5, vamos configurar todos esses parâmetros no construtor da nossa classe Python.

class CTrade:
    
    def __init__(self, magic_number: int, filling_type_symbol: str, deviation_points: int):

Isso reduzirá a margem para erros, pois é possível esquecer de chamar funções separadas, o que levará a erros em tempo de execução que podem ocorrer devido a valores vazios ou ausentes.

Classe CTrade em Python	Classe CTrade incorporada ao MQL5
Operações com ordens
order_open(self, symbol: str, volume: float, order_type: int, price: float, sl: float = 0.0, tp: float = 0.0, type_time: int = mt5.ORDER_TIME_GTC, expiration: datetime = None, comment: str = "") -> bool	OrderOpen	Coloca uma ordem pendente com os parâmetros especificados.
order_modify(self, ticket: int, price: float, sl: float, tp: float, type_time: int = mt5.ORDER_TIME_GTC, expiration: datetime = None, stoplimit: float = 0.0) -> bool:	OrderModify	Altera os parâmetros da ordem pendente para os especificados.
order_delete(self, ticket: int) -> bool	OrderDelete	Exclui uma ordem pendente.
Operações com posições
position_open(self, symbol: str, volume: float, order_type: int, price: float, sl: float, tp: float, comment: str="") -> bool	PositionOpen	Abre uma posição com os parâmetros especificados.
position_modify(self, ticket: int, sl: float, tp: float) -> bool	PositionModify	Altera os parâmetros da posição pelo ticket especificado.
position_close(self, ticket: int, deviation: float=float("nan")) -> bool	PositionClose	Fecha a posição para o símbolo especificado.
Métodos adicionais
buy(self, volume: float, symbol: str, price: float, sl: float=0.0, tp: float=0.0, comment: str="") -> bool	Buy	Abre uma posição longa com os parâmetros especificados.
sell(self, volume: float, symbol: str, price: float, sl: float=0.0, tp: float=0.0, comment: str="") -> bool	Sell	Abre uma posição curta com os parâmetros especificados.
buy_limit(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool	BuyLimit	Coloca uma ordem pendente do tipo Buy Limit com os parâmetros especificados.
sell_limit(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool	BuyStop	Coloca uma ordem pendente do tipo Buy Stop com os parâmetros especificados.
buy_stop(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool	SellLimit	Coloca uma ordem pendente do tipo Sell Limit com os parâmetros especificados.
sell_stop(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool	SellStop	Coloca uma ordem pendente do tipo Sell Stop com os parâmetros especificados.
buy_stop_limit(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool		Coloca uma ordem pendente Buy Stop Limit com os parâmetros especificados.
sell_stop_limit(self, volume: float, price: float, symbol: str, sl: float=0.0, tp: float=0.0, type_time: float=mt5.ORDER_TIME_GTC, expiration: datetime=None, comment: str="") -> bool		Coloca uma ordem pendente Buy Stop Limit com os parâmetros especificados.

Agora, vamos abrir algumas posições e colocar ordens pendentes usando a classe CTrade em Python.

import MetaTrader5 as mt5
from Trade.Trade import CTrade
from Trade.SymbolInfo import CSymbolInfo
from datetime import datetime, timedelta

if not mt5.initialize(r"c:\Users\Omega Joctan\AppData\Roaming\Pepperstone MetaTrader 5\terminal64.exe"):
    print("Failed to initialize Metatrader5 Error = ",mt5.last_error())
    quit()      
    
symbol = "EURUSD"

m_symbol = CSymbolInfo(symbol=symbol)
m_trade = CTrade(magic_number=1001,
                 deviation_points=100,
                 filling_type_symbol=symbol)

m_symbol.refresh_rates()

ask = m_symbol.ask()
bid = m_symbol.bid()

lotsize = m_symbol.lots_min()

# === Market Orders ===

m_trade.buy(volume=lotsize, symbol=symbol, price=ask, sl=0.0, tp=0.0, comment="Market Buy Pos")
m_trade.sell(volume=lotsize, symbol=symbol, price=bid, sl=0.0, tp=0.0, comment="Market Sell Pos")

# expiration time for pending orders
expiration_time = datetime.now() + timedelta(minutes=1)

# === Pending Orders ===

# Buy Limit - price below current ask
m_trade.buy_limit(volume=lotsize, symbol=symbol, price=ask - 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                comment="Buy Limit Order")

# Sell Limit - price above current bid
m_trade.sell_limit(volume=lotsize, symbol=symbol, price=bid + 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                   comment="Sell Limit Order")

# Buy Stop - price above current ask
m_trade.buy_stop(volume=lotsize, symbol=symbol, price=ask + 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                 comment="Buy Stop Order")

# Sell Stop - price below current bid
m_trade.sell_stop(volume=lotsize, symbol=symbol, price=bid - 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                  comment="Sell Stop Order")

# Buy Stop Limit - stop price above ask, limit price slightly lower (near it)
m_trade.buy_stop_limit(volume=lotsize, symbol=symbol, price=ask + 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                       comment="Buy Stop Limit Order")

# Sell Stop Limit - stop price below bid, limit price slightly higher (near it)
m_trade.sell_stop_limit(volume=lotsize, symbol=symbol, price=bid - 0.0020, sl=0.0, tp=0.0, type_time=mt5.ORDER_TIME_SPECIFIED, expiration=expiration_time,
                        comment="Sell Stop Limit Order")

mt5.shutdown()

Resultado

Conclusão

As classes de trading são uma das novidades úteis do MQL5. Antes, precisávamos escrever tudo do zero, o que era muito cansativo e acabava gerando muitos erros, como já expliquei anteriormente. Ao complementar o pacote Python MetaTrader5 com bibliotecas (módulos) em Python, muito semelhantes em sintaxe às usadas em MQL5, os desenvolvedores passaram a poder aplicar em aplicações Python, com máxima eficiência, os conhecimentos adquiridos com o uso do MQL5.

Essas bibliotecas Python personalizadas ajudam a minimizar o problema da falta de suporte ao IntelliSense: depois de adicionar "Docstrings" às suas funções e classes em Python, os editores de texto poderão exibir a documentação do seu código e destacar parâmetros e destacar parâmetros, tornando a escrita do código muito mais agradável e fácil. Por exemplo, dentro do método buy da classe CTrade, há uma breve descrição da função.

class CTrade:
# ....

    def buy(self, volume: float, symbol: str, price: float, sl: float=0.0, tp: float=0.0, comment: str="") -> bool:
        
        """
        Opens a buy (market) position.
        
        Args:
            volume: Trade volume (lot size)
            symbol: Trading symbol (e.g., "EURUSD")
            price: Execution price
            sl: Stop loss price (optional, default=0.0)
            tp: Take profit price (optional, default=0.0)
            comment: Position comment (optional, default="")
        
        Returns:
            bool: True if order was sent successfully, False otherwise
        """

Essa função agora aparecerá documentada no VS Code.

Em termos simples, este artigo serve como documentação das classes de trading para MetaTrader5 que desenvolvi na linguagem de programação Python. Compartilhe suas opiniões na seção de discussões.

Tudo de bom!

Tabela de anexos

Nome e caminho do arquivo	Descrição e uso
Módulos (bibliotecas)
Trade\AccountInfo.py	Contém a classe CAccountInfo.
Trade\DealInfo.py	Contém a classe CDealInfo.
Trade\HistoryOrderInfo.py	Contém a classe CHistoryOrderInfo.
Trade\OrderInfo.py	Contém a classe COrderInfo.
Trade\PositionInfo.py	Contém a classe CPositionInfo.
Trade\SymbolInfo.py	Contém a classe CSymbolInfo.
Trade\TerminalInfo.py	Contém a classe CTerminalInfo.
Trade\Trade.py	Contém a classe CTrade.
Arquivos de teste
accountinfo_test.py	Script para testar os métodos da classe CAccountInfo.
dealinfo_test.py	Script para testar os métodos apresentados na classe CDealInfo.
error_description.py	Contém uma função para descrever erros e retornar seus códigos como strings legíveis por pessoas.
historyorderinfo_test.py	Script para testar os métodos da classe CSymbolInfo.
orderinfo_test.py	Script para testar os métodos da classe COrderInfo.
positioninfo_test.py	Script para testar os métodos da classe CPositionInfo.
symbolinfo_test.py	Script para testar os métodos da classe CSymbolInfo.
terminalinfo_test.py	Script para testar os métodos apresentados na classe CTerminalInfo.
main.py	Script para testar a classe CTrade (pode ser considerado a versão final de um robô de trading em Python).

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/18208

Arquivos anexados |

Baixar como ZIP

Trade_classes_Python.zip (43.78 KB)

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.

Omega J Msigwa

Machine Learning Expert em Omegafx
Tanzânia
34392

https://omegafx.co

Welcome to my profile! I'm a dedicated and passionate Full-Stack Web Developer with an impressive track record of over 4 years in the field. My journey in the world of programming has been an exciting one, marked by a relentless pursuit of knowledge and innovation. I thrive on the challenges of the digital realm, constantly seeking opportunities to expand my skill set and deliver exceptional results.
My favorite programming language is Python, a versatile and powerful tool that I have mastered to a tee. I have harnessed the capabilities of Python in various domains, including backend web development, automation, and much more. Whether it's crafting elegant web solutions, streamlining processes through automation, or delving into data analysis, Python is my trusted companion in these endeavors.

Outros artigos do autor

Últimos Comentários | Ir para discussão (2)

Yevgeniy Koshtenko | 12 jun. 2025 em 14:30

MetaQuotes:

Artigo publicado Criando classes Python para negociação no MetaTrader 5, semelhantes às apresentadas no MQL5:

Autor: Omega J Msigwa

Muito obrigado. Você tem um ótimo artigo

Roman Shiredchenko | 12 jun. 2025 em 18:21

Muito obrigado! Este é um artigo muito útil para projetos futuros.....

Caminhe em novos trilhos: Personalize indicadores no MQL5

Vou agora listar todas as possibilidades novas e recursos do novo terminal e linguagem. Elas são várias, e algumas novidades valem a discussão em um artigo separado. Além disso, não há códigos aqui escritos com programação orientada ao objeto, é um tópico muito importante para ser simplesmente mencionado em um contexto como vantagens adicionais para os desenvolvedores. Neste artigo vamos considerar os indicadores, sua estrutura, desenho, tipos e seus detalhes de programação em comparação com o MQL4. Espero que este artigo seja útil tanto para desenvolvedores iniciantes quanto para experientes, talvez alguns deles encontrem algo novo.

Do iniciante ao especialista: Sistema de análise autogeométrica

Os padrões geométricos oferecem aos traders uma forma concisa de interpretar o movimento dos preços. Muitos analistas desenham linhas de tendência, retângulos e outras figuras manualmente e, em seguida, baseiam suas decisões de negociação nas formações que enxergam. Neste artigo, examinaremos uma alternativa automatizada: o uso de MQL5 para detectar e analisar os padrões geométricos mais populares. Vamos detalhar a metodologia, discutir os detalhes da implementação e mostrar como o reconhecimento automático de padrões pode aprimorar a compreensão do mercado pelo trader.

Está chegando o novo MetaTrader 5 e MQL5

Esta é apenas uma breve resenha do MetaTrader 5. Eu não posso descrever todos os novos recursos do sistema por um período tão curto de tempo - os testes começaram em 09.09.2009. Esta é uma data simbólica, e tenho certeza que será um número de sorte. Alguns dias passaram-se desde que eu obtive a versão beta do terminal MetaTrader 5 e MQL5. Eu ainda não consegui testar todos os seus recursos, mas já estou impressionado.

Algoritmos avançados de execução de ordens em MQL5: TWAP, VWAP e ordens Iceberg

Um framework MQL5 que oferece a traders de varejo algoritmos de execução de nível institucional (TWAP, VWAP, Iceberg) por meio de um gerenciador de execução unificado e de um analisador de desempenho, para fracionar ordens e analisar o desempenho com mais suavidade e precisão.