跳转至

第9章 高级功能

本章介绍 Lean 的高级功能,包括期权策略、期货连续合约、自定义模型和调度事件。

9.1 期权交易

9.1.1 添加期权

def Initialize(self):
    # 添加期权标的
    self.spy_equity = self.AddEquity("SPY", Resolution.Minute).Symbol

    # 添加期权
    self.spy_option = self.AddOption("SPY", Resolution.Minute).Symbol

    # 设置期权链过滤器
    option = self.Securities[self.spy_option]
    option.SetFilter(-2, 2, timedelta(0), timedelta(30))

9.1.2 期权链过滤器

def Initialize(self):
    spy_option = self.AddOption("SPY", Resolution.Minute)

    # 方式1:使用 SetFilter
    # -2: 行权价下限(平价以下2档)
    # 2: 行权价上限(平价以上2档)
    # timedelta(0): 最短到期(当天)
    # timedelta(30): 最长到期(30天)
    spy_option.SetFilter(-2, 2, timedelta(0), timedelta(30))

    # 方式2:使用自定义过滤器
    spy_option.SetFilter(self.OptionFilter)

def OptionFilter(self, universe):
    """自定义期权链过滤器

    过滤器真名:CallsOnly()/PutsOnly()、Strikes(min, max)、
    Expiration(min, max)。无 OnlyCalls/Filter/OnlyExpiringAfter 等方法。
    周度合约默认已包含,IncludeWeeklys() 已废弃。
    """
    # 只选择还有 7-60 天到期、平价上下 2 档以内的看涨期权
    return universe \
        .CallsOnly() \
        .Strikes(-2, 2) \
        .Expiration(timedelta(days=7), timedelta(days=60))

9.1.3 获取期权链

def OnData(self, data):
    # self.OptionChain 是方法(self.OptionChain(self.spy_option)),
    # 无 ContainsKey/GetOptionChain;OnData 里从 data.OptionChains 取链
    if not data.OptionChains.ContainsKey(self.spy_option):
        return

    chain = data.OptionChains[self.spy_option]

    if chain is None:
        return

    # 获取标的当前价格
    underlying_price = chain.Underlying.Price

    # 分离看涨和看跌期权
    calls = [contract for contract in chain if contract.Right == OptionRight.Call]
    puts = [contract for contract in chain if contract.Right == OptionRight.Put]

    # 找到平值看涨期权
    atm_call = min(calls, key=lambda x: abs(x.Strike - underlying_price))

    # 找到最便宜的看跌期权(保护性看跌期权)
    cheapest_put = min(puts, key=lambda x: x.BidPrice)

    self.Debug(f"Underlying: ${underlying_price:.2f}")
    self.Debug(f"ATM Call: Strike={atm_call.Strike}, Bid={atm_call.BidPrice:.2f}")

9.1.4 常见期权策略

Covered Call(备兑看涨期权)

class CoveredCallStrategy(QCAlgorithm):
    """备兑看涨期权策略"""

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.spy_option = self.AddOption("SPY", Resolution.Daily).Symbol

        # 设置过滤器:选择30天后到期的平值看涨期权
        option = self.Securities[self.spy_option]
        option.SetFilter(0, 0, timedelta(25), timedelta(35))

        self.SetWarmUp(TimeSpan.FromDays(60))

    def OnData(self, data):
        # 获取期权链(data.OptionChains 是链集合,无 ContainsKey 的是 self.OptionChain 方法)
        if not data.OptionChains.ContainsKey(self.spy_option):
            return

        chain = data.OptionChains[self.spy_option]
        if chain is None:
            return

        holdings = self.Portfolio[self.spy]

        # 如果没有持有标的,买入100股
        if not holdings.Invested:
            self.SetHoldings(self.spy, 1)
            return

        # 如果还没有卖出看涨期权
        if not any(self.Portfolio[contract.Symbol].Invested
                  for contract in chain):

            # 找到平值看涨期权
            underlying_price = chain.Underlying.Price
            calls = [c for c in chain if c.Right == OptionRight.Call]
            atm_call = min(calls, key=lambda x: abs(x.Strike - underlying_price))

            # 卖出1手看涨期权(1手=100股)
            self.Sell(atm_call.Symbol, 1)
            self.Debug(f"Sold call: Strike={atm_call.Strike}, "
                      f"Expiry={atm_call.Expiry.date()}, "
                      f"Premium=${atm_call.BidPrice:.2f}")

Protective Put(保护性看跌期权)

class ProtectivePutStrategy(QCAlgorithm):
    """保护性看跌期权策略"""

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.spy_option = self.AddOption("SPY", Resolution.Daily).Symbol

        # 选择虚值看跌期权
        option = self.Securities[self.spy_option]
        option.SetFilter(-5, 0, timedelta(25), timedelta(35))

        self.SetWarmUp(TimeSpan.FromDays(60))

    def OnData(self, data):
        if not data.OptionChains.ContainsKey(self.spy_option):
            return

        chain = data.OptionChains[self.spy_option]
        if chain is None:
            return

        holdings = self.Portfolio[self.spy]

        # 买入标的
        if not holdings.Invested:
            self.SetHoldings(self.spy, 1)
            return

        # 检查是否已有看跌期权保护
        has_put_protection = any(
            self.Portfolio[contract.Symbol].Invested and
            contract.Right == OptionRight.Put
            for contract in chain
        )

        if not has_put_protection:
            # 找到虚值5%的看跌期权
            underlying_price = chain.Underlying.Price
            target_strike = underlying_price * 0.95

            puts = [c for c in chain if c.Right == OptionRight.Put]
            otm_put = min(puts, key=lambda x: abs(x.Strike - target_strike))

            # 买入看跌期权(1手保护100股)
            self.Buy(otm_put.Symbol, 1)
            self.Debug(f"Bought protective put: Strike={otm_put.Strike}, "
                      f"Premium=${otm_put.AskPrice:.2f}")

Straddle(跨式策略)

class StraddleStrategy(QCAlgorithm):
    """跨式策略:同时买入相同行权价的看涨和看跌期权"""

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.spy_option = self.AddOption("SPY", Resolution.Daily).Symbol

        # 选择30天后到期的平值期权
        option = self.Securities[self.spy_option]
        option.SetFilter(0, 0, timedelta(25), timedelta(35))

        self.straddle_opened = False

    def OnData(self, data):
        if self.straddle_opened:
            return

        if not data.OptionChains.ContainsKey(self.spy_option):
            return

        chain = data.OptionChains[self.spy_option]
        if chain is None:
            return

        # 找到平值期权
        underlying_price = chain.Underlying.Price
        atm_strike = min(chain, key=lambda x: abs(x.Strike - underlying_price)).Strike

        # 买入平值看涨和看跌期权
        for contract in chain:
            if contract.Strike == atm_strike:
                self.Buy(contract.Symbol, 1)

        self.straddle_opened = True
        self.Debug(f"Opened straddle at strike ${atm_strike}")

9.1.5 期权 Greeks

def OnData(self, data):
    if not data.OptionChains.ContainsKey(self.spy_option):
        return

    chain = data.OptionChains[self.spy_option]
    if chain is None:
        return

    for contract in chain:
        # 获取 Greeks
        delta = contract.Greeks.Delta
        gamma = contract.Greeks.Gamma
        theta = contract.Greeks.Theta
        vega = contract.Greeks.Vega

        self.Debug(f"{contract.Symbol}: "
                  f"Delta={delta:.3f}, "
                  f"Gamma={gamma:.3f}, "
                  f"Theta={theta:.3f}, "
                  f"Vega={vega:.3f}")

9.2 期货交易

9.2.1 添加期货

def Initialize(self):
    # 添加 E-mini S&P 500 期货
    es = self.AddFuture("ES", Resolution.Minute)

    # 设置过滤器
    # 注意:Future.SetFilter 没有 (int, int, TimeSpan, TimeSpan) 四参重载,
    # 只有 (TimeSpan, TimeSpan)/(int, int)/函数重载,这里限定 90 天内到期
    es.SetFilter(timedelta(0), timedelta(days=90))

    # 添加黄金期货
    gc = self.AddFuture("GC", Resolution.Minute)
    gc.SetFilter(timedelta(0), timedelta(days=60))

9.2.2 期货合约滚动

class FutureRollStrategy(QCAlgorithm):
    """期货合约滚动策略"""

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # 添加黄金期货(连续合约)
        self.gc = self.AddFuture("GC", Resolution.Daily).Symbol

        # 设置过滤器:只选择前3个月到期的合约
        future = self.Securities[self.gc]
        future.SetFilter(0, 2)

        self.current_contract = None

    def OnData(self, data):
        # 获取期货链
        # 注意:无 FutureChainSources 枚举、无 self.FutureChain.GetFutureContractList;
        # 具体合约从 data.FutureChains 的 chain.Contracts 取(如需单独订阅
        # 某个具体合约,可对它调用 self.AddFutureContract(contract.Symbol))
        for chain in data.FutureChains:
            if chain.Symbol.Value == "GC":
                contracts = list(chain.Contracts.Values)  # .Values 是 .NET 属性,不加括号

                # 找到最近月份的合约(前端合约)
                front_contract = min(contracts, key=lambda x: x.Expiry)

                if self.current_contract is None:
                    # 开仓
                    self.SetHoldings(front_contract.Symbol, 1)
                    self.current_contract = front_contract.Symbol
                    self.Debug(f"Opened position in {front_contract.Symbol} "
                              f"expiring {front_contract.Expiry.date()}")

                elif self.current_contract != front_contract.Symbol:
                    # 滚动到新合约
                    self.Liquidate(self.current_contract)
                    self.SetHoldings(front_contract.Symbol, 1)
                    self.current_contract = front_contract.Symbol
                    self.Debug(f"Rolled to {front_contract.Symbol} "
                              f"expiring {front_contract.Expiry.date()}")

9.2.3 期货价差交易

class FutureSpreadStrategy(QCAlgorithm):
    """期货价差交易"""

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # 添加两个相关的期货
        self.es = self.AddFuture("ES", Resolution.Daily).Symbol
        self.nq = self.AddFuture("NQ", Resolution.Daily).Symbol

        # 设置过滤器
        self.Securities[self.es].SetFilter(0, 0)
        self.Securities[self.nq].SetFilter(0, 0)

        self.es_contract = None
        self.nq_contract = None

    def OnData(self, data):
        # 从 data.FutureChains 取期货链(无 self.FutureChain.GetFutureContractList)
        es_chain = None
        nq_chain = None
        for chain in data.FutureChains:
            if chain.Symbol.Value == "ES":
                es_chain = chain
            elif chain.Symbol.Value == "NQ":
                nq_chain = chain

        if es_chain is None or nq_chain is None:
            return

        es_contracts = list(es_chain.Contracts.Values)
        nq_contracts = list(nq_chain.Contracts.Values)

        if not es_contracts or not nq_contracts:
            return

        # 选择前端合约
        es_front = min(es_contracts, key=lambda x: x.Expiry)
        nq_front = min(nq_contracts, key=lambda x: x.Expiry)

        if not self.es_contract:
            # 开仓:做多ES,做空NQ(假设它们正相关)
            self.SetHoldings(es_front.Symbol, 0.5)
            self.SetHoldings(nq_front.Symbol, -0.5)
            self.es_contract = es_front.Symbol
            self.nq_contract = nq_front.Symbol

9.3 自定义模型

9.3.1 自定义手续费模型

class TieredFeeModel(FeeModel):
    """
    阶梯式手续费模型

    交易量越大,手续费率越低
    """

    def __init__(self):
        self.total_volume = 0

    def GetOrderFee(self, parameters):
        """计算手续费"""
        security = parameters.Security
        order = parameters.Order

        # 更新累计交易量
        self.total_volume += abs(order.AbsoluteQuantity)

        # 根据交易量确定手续费率
        if self.total_volume < 100000:
            fee_rate = 0.001  # 0.1%
        elif self.total_volume < 1000000:
            fee_rate = 0.0005  # 0.05%
        else:
            fee_rate = 0.0002  # 0.02%

        # 计算手续费
        fee = order.AbsoluteQuantity * security.Price * fee_rate

        # 最低手续费
        fee = max(fee, 1.0)

        return OrderFee(CashAmount(fee, "USD"))

# 使用自定义手续费模型
def Initialize(self):
    spy = self.AddEquity("SPY", Resolution.Minute)
    spy.FeeModel = TieredFeeModel()

9.3.2 自定义滑点模型

class VolumeSlippageModel:
    """
    基于交易量的滑点模型

    订单量占成交量比例越大,滑点越大

    注意:Lean 没有 SlippageModel 基类(只有 ISlippageModel 接口)。
    Python 自定义滑点直接定义一个类,实现 GetSlippageApproximation(
    self, asset, order),返回滑点金额(价格数量级),而非比率
    """

    def GetSlippageApproximation(self, asset, order):
        """计算滑点金额"""
        # 获取平均成交量
        avg_volume = asset.Volume

        if avg_volume == 0:
            return 0

        # 订单量占成交量的比例
        volume_ratio = abs(order.Quantity) / avg_volume

        # 滑点与订单量成正比,最多价格的 0.5%
        slippage_rate = min(volume_ratio * 0.01, 0.005)

        # 返回滑点金额(价格数量级)
        return asset.Price * slippage_rate

# 使用自定义滑点模型
def Initialize(self):
    spy = self.AddEquity("SPY", Resolution.Minute)
    spy.SetSlippageModel(VolumeSlippageModel())

9.3.3 自定义填充模型

class ImmediateFillModel(FillModel):
    """
    立即成交填充模型

    适用于高流动性股票的简化回测

    注意:FillModel 没有 Fill(parameters) 虚方法,需按订单类型
    覆写 MarketFill/LimitFill 等(参考官方
    Algorithm.Python/CustomModelsAlgorithm.py 的 SimpleCustomFillModel)
    """

    def MarketFill(self, asset, order):
        """市价单:立即全量成交"""
        # 买单吃卖一价,卖单吃买一价
        fill_price = asset.AskPrice if order.Direction == OrderDirection.Buy else asset.BidPrice

        # OrderEvent 九参构造:
        # (orderId, symbol, utcTime, status, direction,
        #  fillPrice, fillQuantity, orderFee, message)
        return OrderEvent(
            order.Id,                    # orderId
            asset.Symbol,                # symbol
            Extensions.ConvertToUtc(asset.LocalTime, asset.Exchange.TimeZone),  # utcTime
            OrderStatus.Filled,          # status
            order.Direction,             # direction
            fill_price,                  # fillPrice
            order.Quantity,              # fillQuantity
            OrderFee.Zero,               # orderFee
            "ImmediateFillModel: filled immediately at opposing quote"  # message
        )

# 使用自定义填充模型
def Initialize(self):
    spy = self.AddEquity("SPY", Resolution.Minute)
    spy.SetFillModel(ImmediateFillModel())

9.4 调度事件

9.4.1 基本调度

def Initialize(self):
    # 每天开盘后30分钟执行
    self.Schedule.On(
        self.DateRules.EveryDay("SPY"),
        self.TimeRules.AfterMarketOpen("SPY", 30),
        self.DailyAfterOpen
    )

    # 每天收盘前30分钟执行
    self.Schedule.On(
        self.DateRules.EveryDay("SPY"),
        self.TimeRules.BeforeMarketClose("SPY", 30),
        self.DailyBeforeClose
    )

def DailyAfterOpen(self):
    """每天开盘后30分钟执行"""
    self.Debug(f"After open: {self.Time}")

def DailyBeforeClose(self):
    """每天收盘前30分钟执行"""
    self.Debug(f"Before close: {self.Time}")

9.4.2 周期性调度

def Initialize(self):
    # 每周一执行
    self.Schedule.On(
        self.DateRules.Every(DayOfWeek.Monday),
        self.TimeRules.At(9, 31),
        self.WeeklyRebalance
    )

    # 每月第一个交易日执行
    self.Schedule.On(
        self.DateRules.MonthStart(),
        self.TimeRules.AfterMarketOpen("SPY", 30),
        self.MonthlyRebalance
    )

    # 每季度执行
    # 注意:Lean 的 DateRules 没有季度规则(无 QuarterStart),
    # 惯用做法是每月首个交易日触发,在回调里按月份判断每 3 个月执行一次
    self.Schedule.On(
        self.DateRules.MonthStart(),
        self.TimeRules.AfterMarketOpen("SPY", 30),
        self.QuarterlyRebalance
    )

def QuarterlyRebalance(self):
    """每 3 个月(每季度)执行一次"""
    # 以 2020 年 1 月为起点,每 3 个月放行一次
    months_elapsed = (self.Time.year - 2020) * 12 + (self.Time.month - 1)
    if months_elapsed % 3 != 0:
        return
    # ... 季度调仓逻辑

    # 每年第一个交易日执行
    self.Schedule.On(
        self.DateRules.YearStart(),
        self.TimeRules.AfterMarketOpen("SPY", 30),
        self.YearlyRebalance
    )

9.4.3 条件调度

def Initialize(self):
    # 每月的第15天执行
    # 注意:DateRules.On 只有 On(year, month, day)/On(DateTime...) 这类
    # "指定具体日期"的重载,没有 On(int day);每月固定日的惯用写法是
    # MonthStart 加日偏移(每月 1 号 + 14 天 = 15 号)
    self.Schedule.On(
        self.DateRules.MonthStart(14),
        self.TimeRules.AfterMarketOpen("SPY", 30),
        self.Monthly15th
    )

    # 特定日期范围
    self.Schedule.On(
        self.DateRules.Every([DayOfWeek.Monday, DayOfWeek.Friday]),
        self.TimeRules.At(10, 0),
        self.MondayFriday
    )

9.4.4 多次调度

def Initialize(self):
    # 每天多个时间点执行
    for hour in [10, 11, 14, 15]:
        self.Schedule.On(
            self.DateRules.EveryDay(),
            self.TimeRules.At(hour, 0),
            lambda h=hour: self.HourlyCheck(h)
        )

def HourlyCheck(self, hour):
    """每小时的检查"""
    self.Debug(f"Check at {hour}:00")

9.5 完整示例:期权波动率策略

from AlgorithmImports import *
from datetime import timedelta

class OptionVolatilityStrategy(QCAlgorithm):
    """
    期权波动率策略

    策略逻辑:
    1. 当 VIX 低于 15 时,卖出看跌期权(收取权利金)
    2. 当 VIX 高于 30 时,买入看跌期权(保护)
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # 添加 SPY 和 VIX
        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.vix = self.AddEquity("VIX", Resolution.Daily).Symbol

        # 添加 SPY 期权
        self.spy_option = self.AddOption("SPY", Resolution.Daily).Symbol

        # 选择虚值5%的看跌期权,30天后到期
        option = self.Securities[self.spy_option]
        option.SetFilter(-5, 0, timedelta(25), timedelta(35))

        # 指标
        self.vix_sma = self.SMA(self.vix, 20, Resolution.Daily)

        self.SetWarmUp(TimeSpan.FromDays(60))
        self.put_position = None

    def OnData(self, data):
        if not self.vix_sma.IsReady:
            return

        vix_value = self.Securities[self.vix].Price
        vix_ma = self.vix_sma.Current.Value

        # VIX 低:卖出看跌期权
        if vix_value < 15 and self.put_position is None:
            self.SellPutOption()

        # VIX 高:平仓或买入保护
        elif vix_value > 30:
            if self.put_position:
                self.Liquidate(self.put_position)
                self.put_position = None

    def SellPutOption(self):
        """卖出虚值看跌期权"""
        # self.OptionChain 是方法(无 ContainsKey/GetOptionChain),
        # 返回当前期权链,无数据时为空链,先筛出看跌合约再判空
        chain = self.OptionChain(self.spy_option)

        puts = [c for c in chain if c.Right == OptionRight.Put]
        if not puts:
            return

        # 找到虚值5%的看跌期权
        underlying_price = chain.Underlying.Price
        target_strike = underlying_price * 0.95

        otm_put = min(puts, key=lambda x: abs(x.Strike - target_strike))

        # 卖出看跌期权
        self.Sell(otm_put.Symbol, 1)
        self.put_position = otm_put.Symbol

        self.Debug(f"Sold put at ${otm_put.Strike}, "
                  f"Premium=${otm_put.BidPrice:.2f}, "
                  f"VIX={self.Securities[self.vix].Price:.2f}")