title: Chapter 5: Order Management¶
Chapter 5: Order Management¶
This chapter takes a detailed look at order management in Lean, including basic order types, portfolio management, and order status tracking.
5.1 Order Type Overview¶
5.1.1 Basic Order Types¶
| Order Type | Method | Description |
|---|---|---|
| Market order | MarketOrder() |
Fills immediately at the current market price |
| Limit order | LimitOrder() |
Specify a price; fills at that price or better |
| Stop market order | StopMarketOrder() |
Converts to a market order once triggered |
| Stop limit order | StopLimitOrder() |
Converts to a limit order once triggered |
| Market-on-open order | MarketOnOpenOrder() |
Fills at market price at the next open |
| Market-on-close order | MarketOnCloseOrder() |
Fills at market price at the close (near market close) |
| Combo market order | ComboMarketOrder() |
Multiple legs filled simultaneously at market price |
| Combo limit order | ComboLimitOrder() / ComboLegLimitOrder() |
Limit orders for multi-leg combos |
5.1.2 Order Direction¶
# 正数 = 买入/做多
self.MarketOrder("SPY", 100) # 买入 100 股
# 负数 = 卖出/做空
self.MarketOrder("SPY", -100) # 卖出 100 股
5.2 Basic Order Usage¶
5.2.1 Market Orders¶
def OnData(self, data):
# 基本市价单
self.MarketOrder("SPY", 100) # 买入100股
# 使用 Symbol 对象
symbol = self.Securities["SPY"].Symbol
self.MarketOrder(symbol, 100)
# 返回 OrderTicket 对象
ticket = self.MarketOrder("SPY", 100)
self.Debug(f"Order ID: {ticket.OrderId}")
5.2.2 Limit Orders¶
def OnData(self, data):
current_price = self.Securities["SPY"].Price
# 限价买入单:价格低于当前价
limit_ticket = self.LimitOrder("SPY", 100, current_price * 0.99)
# 限价卖出单:价格高于当前价
sell_ticket = self.LimitOrder("SPY", -100, current_price * 1.01)
# 更新限价单价格(订单状态不是 Filled/Canceled/Invalid 时才算未完结)
if limit_ticket.Status not in (OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid):
# 注意:UpdateOrderFields 只有默认构造函数,Python 中不能传关键字参数,
# 要先创建对象再逐个给属性赋值
update_fields = UpdateOrderFields()
update_fields.LimitPrice = current_price * 0.98
limit_ticket.Update(update_fields)
5.2.3 Stop Orders¶
def OnData(self, data):
entry_price = self.Securities["SPY"].Price
# 买入后设置止损
if not self.Portfolio["SPY"].Invested:
self.MarketOrder("SPY", 100)
# 设置 5% 止损
stop_price = entry_price * 0.95
self.StopMarketOrder("SPY", -100, stop_price)
5.3 Portfolio Management¶
5.3.1 SetHoldings for Proportional Allocation¶
def OnData(self, data):
# 使用 100% 资金买入
self.SetHoldings("SPY", 1)
# 使用 50% 资金买入
self.SetHoldings("SPY", 0.5)
# 使用 100% 资金平均分配多只股票
# 注意:SetHoldings 单次调用只接受一个 Symbol 和权重,
# 多标的等权分配用循环对每只分别下单
tickers = ["AAPL", "MSFT", "GOOGL"]
weight = 1.0 / len(tickers)
for ticker in tickers:
self.SetHoldings(ticker, weight)
5.3.2 Liquidate¶
def OnData(self, data):
# 平掉所有持仓
self.Liquidate()
# 平掉指定证券
self.Liquidate("SPY")
# 平掉多个证券(传入 Symbol 列表)
self.Liquidate([self.aapl, self.msft])
# 取消所有未成交订单
self.Transactions.CancelOpenOrders()
5.4 The OrderTicket Object¶
5.4.1 Getting an OrderTicket¶
# 下单时获取
ticket = self.MarketOrder("SPY", 100)
# 通过 OrderId 获取
ticket = self.Transactions.GetOrderTicket(orderId)
# 获取所有未完结(开放)订单
tickets = self.Transactions.GetOpenOrderTickets()
5.4.2 OrderTicket Properties¶
ticket = self.MarketOrder("SPY", 100)
# 订单信息
order_id = ticket.OrderId
status = ticket.Status
symbol = ticket.Symbol
quantity = ticket.Quantity
type = ticket.OrderType
# 检查订单状态
if status == OrderStatus.Submitted:
self.Debug("订单已提交")
elif status == OrderStatus.Filled:
self.Debug("订单已成交")
elif status == OrderStatus.Canceled:
self.Debug("订单已取消")
5.4.3 Order Statuses¶
| Status | Description |
|---|---|
New |
Newly created |
Submitted |
Submitted |
PartiallyFilled |
Partially filled |
Filled |
Fully filled |
Canceled |
Canceled |
None |
No status yet (the order has not been submitted or has no status record); invalid orders are indicated by Invalid |
Invalid |
Invalid order |
CancelPending |
Cancellation in progress |
UpdateSubmitted |
Update request submitted |
Note: there is no
OrderStatus.Openstatus. To check whether an order is still open, useticket.Status not in (OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid).
5.5 Advanced Order Management¶
5.5.1 Order Updates¶
def OnData(self, data):
# 下单
ticket = self.LimitOrder("SPY", 100, 400)
# 更新订单(未完结时才能更新)
if ticket.Status not in (OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid):
update_fields = UpdateOrderFields()
update_fields.Quantity = 150
update_fields.LimitPrice = 405
update_fields.Tag = "Updated order"
ticket.Update(update_fields)
5.5.2 Order Cancellation¶
def OnData(self, data):
# 取消单个订单
ticket = self.Transactions.GetOrderTicket(orderId)
ticket.Cancel()
# 取消所有未成交订单
self.Transactions.CancelOpenOrders()
# 取消特定证券的所有订单
self.Transactions.CancelOpenOrders("SPY")
5.5.3 Bracket Orders¶
LEAN does not have an OrderBracket-style API that creates three orders automatically in one call. There are two real ways to implement bracket orders:
Option 1: manual bracket orders. After the main order fills (detected in OnOrderEvent), separately place a take-profit limit order and a stop-loss market order:
def Initialize(self):
self.entry_ticket = None
self.take_profit_ticket = None
self.stop_loss_ticket = None
def OnData(self, data):
# 只在没有任何持仓和挂单时入场
if not self.Portfolio.Invested and self.entry_ticket is None:
self.entry_ticket = self.MarketOrder("SPY", 100)
def OnOrderEvent(self, orderEvent):
# 主订单(入场单)成交后,挂出止盈与止损
if self.entry_ticket is not None and orderEvent.OrderId == self.entry_ticket.OrderId \
and orderEvent.Status == OrderStatus.Filled:
fill_price = orderEvent.FillPrice
# 止盈:限价卖出(高于入场价 5%)
self.take_profit_ticket = self.LimitOrder(
"SPY", -100, fill_price * 1.05, tag="Take Profit")
# 止损:止损市价单(低于入场价 5%)
self.stop_loss_ticket = self.StopMarketOrder(
"SPY", -100, fill_price * 0.95, tag="Stop Loss")
Option 2: combo orders. For multi-leg instruments such as options, LEAN provides a real combo order API:
ComboMarketOrder (all legs filled simultaneously at market), ComboLimitOrder (combo limit),
and ComboLegLimitOrder (each leg has its own limit price). They accept a list of Leg objects and submit all legs in a single call.
5.6 Order Event Handling¶
5.6.1 OnOrderEvent¶
def OnOrderEvent(self, orderEvent):
"""
订单状态变化时触发
Args:
orderEvent: OrderEvent 对象(成员有 OrderId、Symbol、Status、
FillPrice、FillQuantity、Direction、OrderFee、Ticket 等)
"""
order_id = orderEvent.OrderId
status = orderEvent.Status
# 订单提交
if status == OrderStatus.Submitted:
self.Debug(f"Order {order_id} submitted")
# 订单成交
elif status == OrderStatus.Filled:
fill_price = orderEvent.FillPrice
fill_quantity = orderEvent.FillQuantity
fee = orderEvent.OrderFee.Value.Amount # OrderFee 对象,金额取 Value.Amount
self.Debug(f"Order {order_id} filled:")
self.Debug(f" Price: ${fill_price}")
self.Debug(f" Quantity: {fill_quantity}")
self.Debug(f" Fee: ${fee}")
# 订单取消
elif status == OrderStatus.Canceled:
self.Debug(f"Order {order_id} canceled")
# 订单无效
elif status == OrderStatus.Invalid:
self.Debug(f"Order {order_id} invalid: {orderEvent.Message}")
5.6.2 Bracket Order Events¶
# 手动括号订单:入场成交后在 OnOrderEvent 中挂出止盈止损
class BracketOrderAlgorithm(QCAlgorithm):
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2023, 12, 31)
self.SetCash(100000)
self.AddEquity("SPY", Resolution.Minute)
self.ticket = None
self.stop_loss_ticket = None
self.take_profit_ticket = None
def OnData(self, data):
if not self.Portfolio.Invested and self.ticket is None:
# 入场:市价买入
self.ticket = self.MarketOrder("SPY", 100)
def OnOrderEvent(self, orderEvent):
# 入场单成交后再挂止损与止盈
if self.ticket is not None and orderEvent.OrderId == self.ticket.OrderId \
and orderEvent.Status == OrderStatus.Filled:
fill_price = orderEvent.FillPrice
# 止损:止损市价卖出
self.stop_loss_ticket = self.StopMarketOrder(
"SPY", -100,
fill_price * 0.95
)
# 止盈:限价卖出
self.take_profit_ticket = self.LimitOrder(
"SPY", -100,
fill_price * 1.05
)
5.7 Complete Example: A Trading Management System¶
from AlgorithmImports import *
class OrderManagementSystem(QCAlgorithm):
"""
完整的订单管理系统示例
功能:
- 自动下单
- 订单状态跟踪
- 止损止盈
- 订单更新和取消
"""
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2023, 12, 31)
self.SetCash(100000)
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
# 创建指标
self.fast_ma = self.SMA(self.spy, 20, Resolution.Hour)
self.slow_ma = self.SMA(self.spy, 50, Resolution.Hour)
# 交易参数
self.position_size = 100
self.stop_loss_pct = 0.02 # 2% 止损
self.take_profit_pct = 0.05 # 5% 止盈
# 订单跟踪
self.entry_order = None
self.stop_order = None
self.profit_order = None
def OnData(self, data):
# 等待指标
if not self.fast_ma.IsReady:
return
price = data[self.spy].Price
# 检查是否有持仓
if self.Portfolio[self.spy].Invested:
# 更新追踪止损
self.UpdateTrailingStop(price)
else:
# 检查入场条件
if self.fast_ma.Current.Value > self.slow_ma.Current.Value:
self.EnterLong(price)
def EnterLong(self, price):
"""开多仓"""
# 买入
self.entry_order = self.MarketOrder(self.spy, self.position_size)
# 计算止损止盈价格
stop_price = price * (1 - self.stop_loss_pct)
profit_price = price * (1 + self.take_profit_pct)
# 设置止损
self.stop_order = self.StopMarketOrder(
self.spy,
-self.position_size,
stop_price
)
# 设置止盈
self.profit_order = self.LimitOrder(
self.spy,
-self.position_size,
profit_price
)
self.Debug(f"Entered long at ${price:.2f}")
self.Debug(f"Stop: ${stop_price:.2f}, Profit: ${profit_price:.2f}")
def UpdateTrailingStop(self, price):
"""更新追踪止损"""
open_statuses = (OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid)
if self.stop_order and self.stop_order.Status not in open_statuses:
# 计算新的止损价:当前价 - 2%
new_stop = price * (1 - self.stop_loss_pct)
# 只有在更有利的情况下才更新
current_stop = self.stop_order.Get(OrderField.StopPrice)
if new_stop > current_stop:
update_fields = UpdateOrderFields()
update_fields.StopPrice = new_stop
self.stop_order.Update(update_fields)
def OnOrderEvent(self, orderEvent):
"""处理订单事件"""
if orderEvent.Status == OrderStatus.Filled:
self.Debug(f"Order filled: {orderEvent.Symbol} @ ${orderEvent.FillPrice:.2f}")