跳转至

第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}")