第5章 订单管理¶
本章详细介绍 Lean 中的订单管理,包括基本订单类型、组合管理和订单状态跟踪。
5.1 订单类型概览¶
5.1.1 基本订单类型¶
| 订单类型 | 方法 | 说明 |
|---|---|---|
| 市价单 | MarketOrder() |
立即以当前市价成交 |
| 限价单 | LimitOrder() |
指定价格,达到或优于该价格时成交 |
| 止损市价单 | StopMarketOrder() |
触发后转为市价单 |
| 止损限价单 | StopLimitOrder() |
触发后转为限价单 |
| 开盘市价单 | MarketOnOpenOrder() |
下个开盘时刻以市价成交 |
| 收盘市价单 | MarketOnCloseOrder() |
收盘时刻以市价成交(接近收盘) |
| 组合市价单 | ComboMarketOrder() |
多腿同时以市价成交 |
| 组合限价单 | ComboLimitOrder() / ComboLegLimitOrder() |
多腿组合的限价订单 |
5.1.2 订单方向¶
# 正数 = 买入/做多
self.MarketOrder("SPY", 100) # 买入 100 股
# 负数 = 卖出/做空
self.MarketOrder("SPY", -100) # 卖出 100 股
5.2 基本订单使用¶
5.2.1 市价单¶
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 限价单¶
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 止损单¶
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 组合管理¶
5.3.1 SetHoldings 按比例分配¶
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 OrderTicket 对象¶
5.4.1 获取 OrderTicket¶
# 下单时获取
ticket = self.MarketOrder("SPY", 100)
# 通过 OrderId 获取
ticket = self.Transactions.GetOrderTicket(orderId)
# 获取所有未完结(开放)订单
tickets = self.Transactions.GetOpenOrderTickets()
5.4.2 OrderTicket 属性¶
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 订单状态¶
| 状态 | 说明 |
|---|---|
New |
新创建 |
Submitted |
已提交 |
PartiallyFilled |
部分成交 |
Filled |
完全成交 |
Canceled |
已取消 |
None |
尚无状态(订单还未提交或无状态记录);无效订单用 Invalid 表示 |
Invalid |
订单无效 |
CancelPending |
取消中 |
UpdateSubmitted |
更新请求已提交 |
注意:没有
OrderStatus.Open这个状态。判断订单"未完结"(仍然开放)应使用ticket.Status not in (OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid)。
5.5 高级订单管理¶
5.5.1 订单更新¶
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 订单取消¶
def OnData(self, data):
# 取消单个订单
ticket = self.Transactions.GetOrderTicket(orderId)
ticket.Cancel()
# 取消所有未成交订单
self.Transactions.CancelOpenOrders()
# 取消特定证券的所有订单
self.Transactions.CancelOpenOrders("SPY")
5.5.3 括号订单(Bracket Order)¶
LEAN 没有 OrderBracket 这类"一句下单自动生成三张订单"的 API。实现括号订单有两种真实做法:
做法一:手动括号订单。 主订单成交后(在 OnOrderEvent 中检测),再分别挂出止盈限价单和止损市价单:
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")
做法二:组合订单。 对于期权等多腿品种,LEAN 提供了真实的组合订单 API:
ComboMarketOrder(多腿同时市价成交)、ComboLimitOrder(组合限价)、
ComboLegLimitOrder(每条腿各自限价)。它们接受 Leg 列表,一次调用同时提交全部腿。
5.6 订单事件处理¶
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 括号订单事件¶
# 手动括号订单:入场成交后在 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 完整示例:交易管理系统¶
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}")