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