Skip to content

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.Open status. To check whether an order is still open, use ticket.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}")