Creación de clases de negociación similares a MQL5 en Python para MetaTrader 5
158
2
Contenido
- Introducción
- La clase CAccountInfo
- La clase CSymbolInfo
- La clase COrderInfo
- La clase CHistoryOrderInfo
- La clase CPositionInfo
- La clase CDealInfo
- La clase CTerminalInfo
- La clase CTrade
- Conclusión
Introducción
La creación de sistemas de trading algorítmico en el lenguaje de programación MQL5 se ha simplificado gracias a las bibliotecas estándar que vienen preinstaladas en MetaEditor. Estos módulos (bibliotecas) incluyen funciones y variables que simplifican el proceso de abrir, validar y cerrar operaciones, etc.
Sin estas dependencias, resulta más difícil escribir incluso un programa sencillo, como crear un script simple para abrir una posición de compra (operación).
Sin la clase 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); } }
Con la clase 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 funciones abren una posición de compra en MetaTrader 5, pero el primer enfoque es muy rudimentario, lleva mucho tiempo y aumenta las probabilidades de producir errores debido a la gran cantidad de líneas de código que hay que escribir para obtener una funcionalidad sencilla.
Por no mencionar que requiere que seas más técnico (para comprender todo lo que implica el proceso de enviar una posición de compra en MetaTrader 5).
Existe un paquete Python denominado MetaTrader 5 que permite a los desarrolladores de Python acceder a la plataforma, obtener casi toda la información de la plataforma (símbolos, posiciones abiertas, etc.) y enviar algunos comandos para abrir, modificar o eliminar operaciones, entre otras cosas. De forma similar a lo que podemos hacer con el lenguaje de programación MQL5.
Por muy útil que sea este paquete, no incluye módulos integrados como los que hay en el lenguaje MQL5 para ayudarnos en el proceso de desarrollo.
Al igual que en el primer ejemplo de programación, escribir un programa sencillo en Python requiere escribir más líneas de código y, lo que es peor, este paquete Python de MetaTrade5 no funciona bien con la mayoría de los entornos de desarrollo integrado (IDE), como Visual Studio Code, lo que significa que no se dispone del útil soporte de programación Intellisense.
Debido a la falta de compatibilidad de Intellisense en los IDE con este paquete, a menudo tendrás que consultar la documentación para recordar conceptos sencillos que has olvidado, en lugar de averiguarlos en el IDE. Esto hace que trabajar con este paquete sea una experiencia terrible.
En este artículo vamos a implementar las clases comerciales en Python sobre el paquete MetaTrader 5 para ayudarnos a escribir programas de manera efectiva en Python como en MQL5.
La clase CAccountInfo
En MQL5 esta clase es para trabajar con propiedades de cuentas comerciales. Se puede acceder a toda la información sobre la cuenta comercial de un bróker usando esta clase, hagamos su equivalente en Python.
Clase comercial CAccountInfo personalizada de Python | Clase comercial CAccountInfo integrada en MQL5 | Descripción |
|---|---|---|
Propiedades de tipo entero (int) y cadena (string) | ||
login() | Login | Obtiene el número de cuenta. |
trade_mode() | TradeMode | Obtiene el modo comercial. |
trade_mode_description() | TradeModeDescription | Obtiene el modo comercial como una cadena (string). |
leverage() | Leverage | Obtiene la cantidad de apalancamiento. |
stopout_mode() | StopoutMode | Obtiene la configuración del modo de parada (StopOut). |
stopout_mode_description() | StopoutModeDescription | Obtiene el modo de parada estableciéndolo como una cadena (string). |
margin_mode() | MarginMode | Obtiene el modo de cálculo de margen. |
margin_mode_description() | MarginModeDescription | Obtiene el modo de cálculo de margen como una cadena (string). |
trade_allowed() | TradeAllowed | Obtiene la bandera de asignación comercial. |
trade_expert() | TradeExpert | Obtiene la bandera de la autorización comercial automatizada. |
limit_orders() | LimitOrders | Obtiene el número máximo de órdenes pendientes permitidas. |
Propiedades de tipo doble (double) | ||
balance() | Balance | Obtiene el saldo de la cuenta MetaTrader 5. |
credit() | Credit | Obtiene la cantidad de crédito otorgado. |
profit() | Profit | Obtiene la cantidad de beneficio actual en una cuenta. |
equity() | Equity | Obtiene el importe del saldo actual de la cuenta. |
margin() | Margen | Obtiene la cantidad de margen reservado. |
free_margin() | FreeMargin | Obtiene la cantidad de margen libre. |
margin_level() | MarginLevel | Obtiene el nivel de margen. |
margin_call() | MarginCall | Obtiene el nivel de margen para el depósito. |
margin_stopout() | MarginStopOut | Obtiene el nivel de margen para el StopOut. |
Propiedades tipo texto | ||
name() | Name | Obtiene el nombre de la cuenta. |
server() | Server | Obtiene el nombre del servidor comercial. |
company() | Company | Obtiene el nombre de la empresa que atiende la cuenta. |
currency() | Currency | Obtiene el nombre de la moneda de depósito. |
Métodos adicionales | ||
margin_check(self, symbol, order_type, volume, price) | MarginCheck | Obtiene la cantidad de margen necesaria para ejecutar la operación comercial. |
free_margin_check(self, symbol, order_type, volume, price) | FreeMarginCheck | Obtiene la cantidad de margen libre restante después de la ejecución de la operación comercial. |
order_profit_check(self, symbol, order_type, volume, price_open, price_close) | OrderProfitCheck | Obtiene la ganancia evaluada en función de los parámetros pasados. |
max_lot_check(self, symbol, order_type, price, percent=100) | MaxLotCheck | Obtiene el máximo volumen posible de operación comercial. |
Ejemplo 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()
Resultado:
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 -------------------
La clase CSymbolInfo
Esta clase proporciona acceso a las propiedades del símbolo.
Clase CSymbolInfo personalizada de Python | Clase CSymbolInfo incorporada en MQL5 | Descripción |
|---|---|---|
Controles | ||
refresh() | Refresh | Actualiza los datos del símbolo. |
refresh_rates() | RefreshRates | Actualiza las cotizaciones de los símbolos. |
Propiedades | ||
name() | Name | Obtiene el nombre del símbolo. |
select(self, select=True) | Select | Agrega o elimina el símbolo de "Observación del mercado". |
is_synchronized() | IsSynchronized | Comprueba la sincronización del símbolo con el servidor. |
| Volúmenes | ||
volume() | Volume | Obtiene el volumen de la última operación. |
volume_high() | VolumeHigh | Obtiene el volumen máximo diário. |
volume_low() | VolumeLow | Obtiene el volumen mínimo diário. |
Misceláneas | ||
time() | Time | Obtiene la hora de la última cotización. |
spread() | Spread | Obtiene la cantidad de spread (en puntos). |
spread_float() | SpreadFloat | Obtiene la bandera de spread flotante. |
ticks_book_depth() | TicksBookDepth | Obtiene la profundidad de guardado de ticks. |
Niveles | ||
stops_level() | StopsLevel | Obtiene la parada mínima para las órdenes (en puntos). |
freeze_level() | FreezeLevel | Obtiene la distancia de congelación de las operaciones comerciales (en puntos). |
Precios de compra | ||
bid() | Bid | Obtiene el precio de oferta actual. |
bid_high() | BidHigh | Obtiene el precio de oferta máximo para un día. |
bid_low() | BidLow | Obtiene el precio de oferta mínimo para un día. |
Precios de venta | ||
ask() | Ask | Obtiene el precio de oferta (venta) actual |
ask_high() | AskHigh | Obtiene el precio de venta máximo por día |
ask_low() | AskLow | Obtiene el precio mínimo de venta por un día. |
Precios | ||
last() | Last | Devuelve el último precio actual. |
last_high() | LastHigh | Devuelve el último precio máximo de un día. |
last_low() | LastLow | Devuelve el último precio mínimo de un día. |
| Modos de comercio | ||
trade_calc_mode() | TradeCalcMode | Obtiene el modo de cálculo del costo del contrato en formato entero. |
trade_calc_mode_description() | TradeCalcModeDescription | Obtiene el modo de cálculo del costo del contrato en formato de cadena (string). |
trade_mode() | TradeMode | Obtiene el tipo de ejecución de la orden en formato entero (int). |
trade_mode_description() | TradeModeDescription | Obtiene el tipo de ejecución de la orden en formato de cadena (string). |
trade_execution() | TradeExecution | Obtiene el modo de ejecución comercial en formato entero (int). |
trade_execution_description() | TradeExecutionDescription | Obtiene el modo de ejecución comercial en formato de cadena (string). |
Swaps | ||
swap_mode() | SwapMode | Obtiene el modo de cálculo de swap en formato entero (int). |
swap_mode_description() | SwapModeDescription | Obtiene el modo de cálculo de swap en formato de cadena (string). |
swap_rollover_3days() | SwapRollover3days | Obtiene el día del cargo de triple swap como un entero (int). |
swap_rollover_3days_description() | SwapRollover3daysDescription | Obtiene el día del cargo de triple swap como una cadena (string). |
Margen | ||
margin_initial() | MarginInitial | Obtiene el valor del margen inicial. |
margin_maintenance() | MarginMaintenance | Obtiene el valor del margen de mantenimiento. |
margin_hedged() | Devuelve el valor del margen cubierto para el símbolo dado. | |
margin_hedged_use_leg() | Devuelve un valor booleano que indica si el margen cubierto se aplica a cada pierna (lado de la posición) individualmente. | |
Información de tick | ||
digits() | Digits | Obtiene el número de dígitos después del punto. |
point() | Point | Obtiene el valor de un punto. |
tick_value() | TickValue | Obtiene el valor del tick (cambio mínimo de precio). |
tick_value_profit() | TickValueProfit | Obtiene el precio de tick calculado de una posición rentable. |
tick_value_loss() | TickValueLoss | Obtiene el precio de tick calculado para una posición perdedora. |
tick_size() | TickSize | Obtiene el cambio mínimo de precio. |
Tamaños de contratos | ||
contract_size() | ContractSize | Obtiene el monto del contrato comercial. |
lots_min() | LotsMin | Obtiene el volumen mínimo para cerrar un contrato. |
lots_max() | LotsMax | Obtiene el volumen máximo para cerrar un contrato. |
lots_step() | LotsStep | Obtiene el paso mínimo de cambio de volumen para cerrar un contrato. |
lots_limit() | LotsLimit | Obtiene el volumen máximo permitido de posiciones abiertas y órdenes pendientes en cualquier dirección para un símbolo. |
Swaps | ||
swap_long() | SwapLong | Obtiene el valor del swap de posición larga. |
swap_short() | SwapShort | Obtiene el valor del swap de posición corta. |
Símbolo/Información sobre la moneda | ||
currency_base() | CurrencyBase | Obtiene el nombre de la moneda base del símbolo. |
currency_profit() | CurrencyProfit | Obtiene el nombre de la moneda de beneficio. |
currency_margin() | CurrencyMargin | Obtiene el nombre de la moneda de margen. |
bank() | Bank | Obtiene el nombre de la fuente de cotización actual. |
description() | Descripción | Obtiene la cadena de caracteres que describe un símbolo. |
path() | Path | Obtiene la ruta en el árbol de símbolos. |
page() | La dirección de una página web que contiene información del símbolo. | |
Información de la sesión | ||
session_deals() | SessionDeals | Obtiene el número de transacciones en la sesión actual. |
session_buy_orders() | SessionBuyOrders | Obtiene el número de órdenes de compra actual. |
session_sell_orders() | SessionSellOrders | Obtiene el número de órdenes de venta actuales. |
session_turnover() | SessionTurnover | Obtiene el resumen del volumen de negocios de la sesión actual. |
session_interest() | SessionInterest | Obtiene el resumen del interés abierto de la sesión actual. |
session_buy_orders_volume() | SessionBuyOrdersVolume | Obtiene el volumen de órdenes de compra. |
session_sell_orders_volume() | SessionSellOrdersVolume | Obtiene el volumen de órdenes de venta. |
session_open() | SessionOpen | Obtiene el precio de apertura de la sesión actual. |
session_close() | SessionClose | Obtiene el precio de cierre de la sesión actual. |
session_aw() | SessionAW | Obtiene el precio promedio ponderado de la sesión actual. |
session_price_settlement() | SessionPriceSettlement | Obtiene el precio de liquidación de la sesión actual. |
session_price_limit_min() | SessionPriceLimitMin | Obtiene el precio mínimo de la sesión actual. |
session_price_limit_max() | SessionPriceLimitMax | Obtiene el precio máximo de la sesión actual. |
Estos son algunos de los métodos de la clase Python, una lista completa se puede ver dentro del archivo SymbolInfo.py.
Ejemplo 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()
Resultado:
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 ---------------------
La clase COrderInfo
Esta clase proporciona acceso a las propiedades de la orden pendiente.
Clase COrderInfo personalizada de Python | Clase COrderInfo incorporada de MQL5 | Descripción |
|---|---|---|
Propiedades de tipo entero y de fecha y hora | ||
ticket() | Ticket | Obtiene el ticket de un pedido, previamente seleccionado para acceder. |
type_time() | TypeTime | Obtiene el tipo de orden en el momento de la expiración. |
type_time_description() | TypeTimeDescription | Obtiene el tipo de orden por vencimiento como una cadena (string). |
time_setup() | TimeSetup | Obtiene la hora de colocación del pedido. |
time_setup_msc() | TimeSetupMsc | Recibe el tiempo de realización de un pedido en milisegundos desde el 01.01.1970. |
order_type() | OrderType | Obtiene el tipo de orden en formato entero. |
order_type_description() | OrderTypeDescription | Obtiene el tipo de pedido como una cadena (string). |
state() | State | Obtiene el estado del pedido como un entero. |
state_description() | StateDescription | Obtiene el estado del pedido como una cadena. |
magic() | Magic | Obtiene el ID del experto que realizó el pedido. |
position_id() | PositionId | Obtiene el ID de la posición. |
type_filling() | TypeFilling | Obtiene el tipo de ejecución de la orden por resto como un entero. |
type_filling_description() | TypeFillingDescription | Obtiene el tipo de ejecución de la orden por resto como una cadena. |
time_done() | TimeDone | Obtiene la hora de ejecución o cancelación de la orden. |
time_done_msc() | TimeDoneMsc | Recibe el tiempo de ejecución o cancelación de la orden en milisegundos desde el 01.01.1970. |
time_expiration() | TimeExpiration | Obtiene la hora de vencimiento del pedido. |
Propiedades de tipo doble | ||
volume_initial() | VolumeInitial | Obtiene el volumen inicial del pedido. |
volume_current() | VolumeCurrent | Obtiene el volumen no completado del pedido. |
price_open() | PriceOpen | Obtiene el precio del pedido. |
price_current() | PriceCurrent | Obtiene el precio actual por símbolo de orden. |
stop_loss() | StopLoss | Obtiene el Stop Loss de la orden. |
take_profit() | TakeProfit | Obtiene el Take Profit de la orden. |
price_stop_limit() | PriceStopLimit | Obtiene el precio de una orden limitada. |
Acceso a las propiedades del texto | ||
comment() | Symbol | Obtiene el comentario del pedido. |
symbol() | Comment | Obtiene el nombre del símbolo de orden. |
Selección | ||
select_order(self, order) -> bool | Selecciona un pedido por su objeto (diccionario) de la lista de pedidos devuelta por la función MetaTrader5.orders_get(). |
Ejemplo 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()
Resultado:
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
La clase CHistoryOrderInfo
Esta clase proporciona acceso fácil a las propiedades del orden histórico.
Clase CHistoryOrderInfo personalizada de Python | Clase CHistoryOrderInfo incorporada en MQL5 | Descripción |
|---|---|---|
Propiedades de tipo entero, fecha y hora, y cadena | ||
time_setup() | TimeSetup | Obtiene la hora de colocación del pedido. |
time_setup_msc() | TimeSetupMsc | Devuelve el tiempo transcurrido desde el 01.01.1970 en milisegundos hasta el momento de realizar un pedido. |
time_done() | TimeDone | Obtiene la hora de ejecución o cancelación de la orden. |
time_done_msc() | TimeDoneMsc | Devuelve el tiempo de ejecución o cancelación de la orden en milisegundos desde el 01.01.1970. |
magic() | Magic | Obtiene el ID de un asesor experto que realizó una orden seleccionada. |
ticket() | Devuelve el ticket del pedido seleccionado. | |
order_type() | OrderType | Devuelve el tipo de orden seleccionado. |
order_type_description() | OrderTypeDescription | Devuelve el tipo del pedido seleccionado como una cadena. |
state() | State | Devuelve el estado del pedido como un entero. |
state_description() | StateDescription | Devuelve el estado del pedido como una cadena. |
time_expiration() | TimeExpiration | Obtiene la hora de vencimiento del pedido seleccionado. |
type_filling() | TypeFilling | Obtiene el tipo de ejecución de la orden por resto en formato entero. |
type_filling_description() | TypeFillingDescription | Obtiene el tipo de ejecución de la orden por resto como una cadena. |
type_time() | TypeTime | Obtiene el tipo de la orden seleccionada en el momento del vencimiento como un entero. |
type_time_description() | TypeTimeDescription | Obtiene el tipo de orden seleccionado en el momento del vencimiento en formato de cadena. |
position_id() | PositionId | Obtiene el ID de la posición. |
Propiedades de tipo doble | ||
volume_initial() | VolumeInitial | Obtiene el volumen inicial de la orden seleccionada. |
volume_current() | VolumeCurrent | Obtiene el volumen no completado del pedido seleccionado. |
price_open() | PriceOpen | Obtiene el precio del pedido seleccionado. |
price_current() | PriceCurrent | Obtiene el precio actual por símbolo de orden. |
stop_loss() | StopLoss | Obtiene el stop loss de la orden seleccionada. |
take_profit() | TakeProfit | Obtiene el take profit de la orden seleccionada. |
price_stop_limit() | PriceStopLimit | Obtiene el precio de una orden limitada seleccionada. |
| Propiedades del texto | ||
symbol() | Symbol | Devuelve el símbolo de un pedido seleccionado. |
comment() | Comment | Devuelve el comentario de un pedido seleccionado. |
Selección | ||
select_order(self, order) -> bool | Selecciona una orden por su objeto de una lista de objetos (diccionarios) devuelta por la función MetaTrader5.history_orders_get. |
Ejemplo 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()
Resultado:
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
La clase CPositionInfo
Esta clase proporciona acceso fácil a las propiedades de las posiciones abiertas.
Clase CPositionInfo personalizada de Python | Clase CPositionInfo incorporada en MQL5 | Descripción |
|---|---|---|
Propiedades de tipo entero y fecha/hora | ||
ticket() | Obtiene el ticket de una posición, previamente seleccionada para acceder. | |
time() | Time | Obtiene la hora de apertura de la posición. |
time_msc() | TimeMsc | Recibe el tiempo de colocación de una posición en milisegundos desde el 01.01.1970. |
time_update() | TimeUpdate | Recibe el tiempo del cambio de posición en segundos desde el 01.01.1970. |
time_update_msc() | TimeUpdateMsc | Recibe el tiempo del cambio de posición en milisegundos desde el 01.01.1970. |
position_type() | PositionType | Obtiene el tipo de posición como un entero. |
position_type_description() | TypeDescription | Obtiene el tipo de posición como una cadena. |
magic() | Magic | Obtiene el ID del experto que abrió la posición. |
position_id() | Identifier | Obtiene el ID de la posición. |
Propiedades de tipo doble | ||
volume() | Volume | Obtiene el volumen de la posición. |
price_open() | PriceOpen | Obtiene el precio de apertura de la posición. |
stop_loss() | StopLoss | Obtiene el precio del Stop Loss de la posición. |
take_profit() | TakeProfit | Obtiene el precio del Take Profit de la posición. |
price_current() | PriceCurrent | Obtiene el precio actual por símbolo de posición. |
profit() | Profit | Obtiene la cantidad de beneficio actual por posición. |
swap() | Swap | Obtiene la cantidad de intercambio por posición. |
Acceso a las propiedades del texto | ||
comment() | Comment | Obtiene el comentario de la posición. |
symbol() | Symbol | Obtiene el nombre del símbolo de posición. |
Selección | ||
select_position(self, position) -> bool | Selecciona el objeto de posición (diccionario) de una lista de posiciones devuelta por la función MetaTrader5.positions_get(). |
Ejemplo 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()
Resultado:
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:
La clase CDealInfo
Esta clase proporciona acceso a las propiedades de las operaciones desde el programa MetaTrader 5.
Clase CDealInfo personalizada de Python | Clase CDealInfo incorporada en MQL5 | Descripción |
|---|---|---|
Propiedades de tipo entero y fecha y hora | ||
ticket() | Entrega el ticket de una oferta seleccionada. | |
time() | Time | Obtiene la hora de ejecución de la operación. |
time_msc() | TimeMsc | Recibe la hora de ejecución de una operación en milisegundos desde el 01.01.1970. |
deal_type() | DealType | Obtiene el tipo de operación. |
type_description() | TypeDescription | Obtiene el tipo de operación como una cadena. |
entry() | Entry | Obtiene la dirección de la operación. |
entry_description() | EntryDescription | Obtiene la dirección de la operación como una cadena. |
magic() | Magic | Obtiene el ID del experto que ejecutó la operación. |
position_id() | PositionId | Obtiene el ID de la posición en la que se realizó la operación. |
Propiedades de tipo doble (double) | ||
volume() | Volume | Obtiene el volumen (tamaño del lote) de la operación. |
price() | Price | Obtiene el precio de la operación. |
commission() | Commision | Obtiene la comisión de la operación. |
swap() | Swap | Obtiene la cantidad de swap cuando se cierra la posición. |
profit() | Profit | Obtiene el resultado financiero (beneficio) de la operación. |
Propiedades de tipo cadena | ||
symbol() | Symbol | Obtiene el nombre del símbolo de la operación seleccionada. |
comment() | Comment | Obtiene el comentario de la operación seleccionada. |
Selection | ||
select_by_index(self, index) | Selecciona la operación por índice. | |
select_deal(self, deal) -> bool | Selecciona una operación por su objeto (diccionario) de la lista de operaciones devuelta por la función MetaTrader5.history_deals_get. |
Ejemplo 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()
Resultado:
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:
La clase CTerminalInfo
Esta clase proporciona acceso a las propiedades del entorno del programa MetaTrader 5.
Clase CTerminalInfo personalizada de Python | Clase CTerminalInfo incorporada en MQL5 | Descripción |
|---|---|---|
Propiedades de tipo cadena | ||
name() | Name | Obtiene el nombre del terminal del cliente. |
company() | Company | Obtiene el nombre de la empresa del terminal del cliente. |
language() | Language | Obtiene el idioma del terminal del cliente. |
path() | Path | Obtiene la carpeta de la terminal del cliente. |
data_path() | DataPath | Obtiene la carpeta de datos para la terminal del cliente. |
common_data_path() | CommonDataPath | Obtiene la carpeta de datos común de todos los terminales de cliente (todas las aplicaciones MetaTrade5 instaladas en la computadora. |
Propiedades de tipo entero | ||
build() | Build | Obtiene el número de compilación del terminal del cliente. |
is_connected() | IsConnected | Obtiene la información sobre la conexión al servidor comercial. |
is_dlls_allowed() | IsDLLsAllowed | Obtiene la información sobre el permiso de uso de DLL. |
is_trade_allowed() | IsTradeAllowed | Obtiene la información sobre el permiso para comerciar. |
is_email_enabled() | IsEmailEnabled | Obtiene la información sobre el permiso para enviar correos electrónicos al servidor SMTP y el inicio de sesión, especificado en la configuración del terminal. |
is_ftp_enabled() | IsFtpEnabled | Obtiene la información sobre el permiso para enviar informes comerciales al servidor FTP y el inicio de sesión, especificado en la configuración del terminal. |
are_notifications_enabled() | Comprueba si las notificaciones push están habilitadas en la configuración del terminal MetaTrader 5. | |
is_community_account() | Comprueba si el terminal actual está conectado a la comunidad MetaTrader en mql5.com (este sitio web). | |
is_community_connection() | Comprueba si el terminal tiene una conexión activa a los servicios de la comunidad MQL5. | |
is_mqid() | Comprueba si el usuario ha iniciado sesión con su MQID (ID de MetaQuotes). | |
is_tradeapi_disabled() | Comprueba si la API de comercio está deshabilitada en la configuración de MetaTrader 5. | |
max_bars() | MaxBars | Obtiene la información sobre el número máximo de barras en el gráfico. |
code_page() | Devuelve el valor entero que representa la página de códigos actual (codificación de caracteres) utilizada por la terminal MetaTrader 5. | |
ping_last() | Devuelve el último tiempo de ping registrado (en microsegundos) entre la terminal MetaTrader y el servidor del bróker. | |
community_balance() | Devuelve el saldo actual de la cuenta de la comunidad MQL5 del usuario. | |
retransmission() | Devuelve la tasa de retransmisión de datos desde el servidor al terminal. |
Ejemplo 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()
Resultado:
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
La clase CTrade
Esta clase proporciona acceso fácil a las funciones comerciales. A diferencia de las clases anteriores que devuelven información sobre los símbolos, la terminal MetaTrader 5, las transacciones históricas y la cuenta, esta función es lo que necesitamos para abrir operaciones.
Configuración de parámetros
En lugar de establecer parámetros como Número mágico, tipo de relleno y valor de desviación en puntos utilizando funciones separadas como en la clase CTrade MQL5, en nuestra clase Python configuremos todas ellas en un constructor de clase.
class CTrade: def __init__(self, magic_number: int, filling_type_symbol: str, deviation_points: int):
Esto reduce el margen de error, ya que se podría olvidar llamar a funciones separadas, lo que daría lugar a errores de tiempo de ejecución que podrían ocurrir debido a valores vacíos o nulos.
Clase CTrade personalizada de Python | Clase CTrade incorporada en MQL5 | |
|---|---|---|
El funcionamiento con órdenes | ||
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 una orden pendiente con 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 | Modifica la orden pendiente con parámetros especificados. |
order_delete(self, ticket: int) -> bool | OrderDelete | Elimina una orden pendiente. |
El funcionamiento con posiciones | ||
position_open(self, symbol: str, volume: float, order_type: int, price: float, sl: float, tp: float, comment: str="") -> bool | PositionOpen | Abre una posición con parámetros especificados. |
position_modify(self, ticket: int, sl: float, tp: float) -> bool | PositionModify | Modifica los parámetros de posición según el ticket especificado. |
position_close(self, ticket: int, deviation: float=float("nan")) -> bool | PositionClose | Cierra una posición para el símbolo especificado. |
Métodos adicionales | ||
buy(self, volume: float, symbol: str, price: float, sl: float=0.0, tp: float=0.0, comment: str="") -> bool | Buy | Abre una posición de compra con los parámetros especificados. |
sell(self, volume: float, symbol: str, price: float, sl: float=0.0, tp: float=0.0, comment: str="") -> bool | Sell | Abre una posición de venta con los 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 | Abre una orden pendiente del tipo Buy Limit con 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 | SellLimit | Abre una orden pendiente del tipo Sell Limit con 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 | BuyStop | Coloca una orden pendiente del tipo Buy Stop con 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 una orden pendiente del tipo Sell Stop con 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 | BuyStopLimi | Coloca una orden pendiente del tipo límite Buy Stop con parámetros específicos. |
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 | SellStopLimit | Coloca una orden pendiente del límite Sell Stop con parámetros especificados. |
Ahora, usemos la clase CTrade en Python para abrir un par de posiciones y órdenes pendientes.
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()
Resultados
Conclusión
Las clases comerciales son una de las cosas buenas que han surgido en MQL5. Antes solíamos escribir todo desde cero, algo que resulta extremadamente tedioso y da lugar a muchos errores, como he explicado anteriormente. Al ampliar el paquete Python de MetaTrader 5 a bibliotecas (módulos) en Python, cuya sintaxis es muy similar a la de MQL5, se ayuda a los desarrolladores a aprovechar los conocimientos que ya tienen sobre MQL5 para aplicaciones Python.
Estas bibliotecas Python personalizadas pueden ayudar a mitigar el problema de compatibilidad con Intellisense, al añadir «Docstrings» en tus funciones y clases Python. Los editores de texto como Visual Studio Code pueden ayudarte a documentar tu código y resaltar los parámetros, lo que hace que el proceso de codificación sea más divertido y mucho más fácil. Por ejemplo, dentro del método buy de la clase CTrade hay una breve descripción de la función.
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 """
Esta función se describirá ahora en VS Code.
En pocas palabras, este artículo sirve como documentación de las clases comerciales para MetaTrader5 que creé en el lenguaje de programación Python. Por favor, déjeme saber su opinión en la sección de comentarios.
Saludos cordiales.
Tabla de archivos adjuntos
Nombre del archivo y ruta | Descripción y uso |
|---|---|
Módulos (bibliotecas) | |
| Trade\AccountInfo.py | Contiene la clase CAccountInfo. |
| Trade\DealInfo.py | Contiene la clase CDealInfo. |
| Trade\HistoryOrderInfo.py | Contiene la clase CHistoryOrderInfo. |
| Trade\OrderInfo.py | Contiene la clase COrderInfo. |
| Trade\PositionInfo.py | Contiene la clase CPositionInfo. |
| Trade\SymbolInfo.py | Contiene la clase CSymbolInfo. |
| Trade\TerminalInfo.py | Contiene la clase CTerminalInfo. |
| Trade\Trade.py | Contiene la clase CTrade. |
Archivos de prueba | |
| accountinfo_test.py | Un script para probar los métodos ofrecidos por la clase CAccountInfo. |
| dealinfo_test.py | Un script para probar los métodos ofrecidos por la clase CDealInfo. |
| error_description.py | Contiene una función para describir códigos de error y de retorno en cadenas legibles para humanos. |
| historyorderinfo_test.py | Un script para probar los métodos ofrecidos por la clase CHistoryOrderInfo. |
| orderinfo_test.py | Un script para probar los métodos ofrecidos por la clase COrderInfo. |
| positioninfo_test.py | Un script para probar los métodos ofrecidos por la clase CPositionInfo. |
| symbolinfo_test.py | Un script para probar los métodos ofrecidos por la clase CSymbolInfo. |
| terminalinfo_test.py | Un script para probar los métodos ofrecidos por la clase CTerminal. |
| main.py | Un script para probar la clase CTrade, considéralo como un robot de trading definitivo en Python. |
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/18208
Archivos adjuntos |
Trade_classes_Python.zip
(43.78 KB)
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
Algoritmo de camello — Camel Algorithm (CA)
El algoritmo del camello, desarrollado en 2016, modela el comportamiento de los camellos en el desierto para resolver problemas de optimización, considerando factores como la temperatura, las reservas y la resistencia. Este artículo presenta una versión modificada del mismo (CAm) con mejoras clave: el uso de una distribución gaussiana en la generación de soluciones y la optimización de los parámetros del efecto oasis.
Criterio de independencia de Hilbert-Schmidt (HSIC)
El presente artículo analiza la prueba estadística no paramétrica HSIC (Criterio de Independencia de Hilbert-Schmidt) diseñada para identificar dependencias lineales y no lineales en los datos. Para el cálculo de HSIC en el lenguaje MQL5, se propone la implementación de dos algoritmos: la prueba de permutación exacta y la aproximación gamma. La eficacia de los métodos se demuestra en el modelado de datos sintéticos de una relación no lineal entre las características y la variable objetivo.
Visión por computadora para el trading (Parte 2): Complicamos la arquitectura para el análisis 2D de imágenes RGB
La visión por computadora para el trading: cómo funciona y cómo se desarrolla paso a paso. Creamos un algoritmo para reconocer imágenes RGB de los gráficos de precios utilizando un mecanismo de atención y una capa LSTM bidireccional. Como resultado, obtenemos un modelo de trabajo para predecir el precio del euro-dólar con una precisión de hasta el 55% en la sección de validación.
De principiante a experto: sistema de análisis autogeométrico
Los patrones geométricos ofrecen a los operadores una forma concisa de interpretar la acción del precio. Muchos analistas dibujan líneas de tendencia, rectángulos y otras formas a mano y luego basan sus decisiones comerciales en las formaciones que ven. En este artículo exploramos una alternativa automatizada: aprovechar MQL5 para detectar y analizar los patrones geométricos más populares. Desglosaremos la metodología, discutiremos los detalles de implementación y destacaremos cómo el reconocimiento de patrones automatizado puede agudizar el conocimiento del mercado de un comerciante.
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Artículo publicado Creación de clases Python para operar en MetaTrader 5, similares a las presentadas en MQL5:
Autor: Omega J Msigwa
muchas gracias! es un artículo muy útil para futuros proyectos.....