第16章 代码组织与设计模式¶
本章介绍 Lean 项目的最佳代码组织方式和常用设计模式。
16.1 项目结构¶
16.1.1 推荐的项目结构¶
LeanProject/
├── algorithms/ # 策略目录
│ ├── strategies/ # 具体策略
│ │ ├── MeanReversion.py
│ │ ├── Momentum.py
│ │ └── Arbitrage/
│ ├── framework/ # Framework模型
│ │ ├── alpha/
│ │ │ ├── RsiAlpha.py
│ │ │ └── MacdAlpha.py
│ │ ├── portfolio/
│ │ ├── risk/
│ │ └── universe/
│ └── base/ # 基础类
│ ├── BaseStrategy.py
│ └── BaseAlpha.py
├── indicators/ # 自定义指标
│ ├── CustomIndicators.py
│ └── CompositeIndicators.py
├── library/ # 工具库
│ ├── helpers.py
│ ├── statistics.py
│ └── technicals.py
├── data/ # 数据文件
│ └── custom/
│ └── custom_data.csv
├── tests/ # 测试
│ ├── test_strategies.py
│ └── test_indicators.py
├── config/ # 配置文件
│ ├── backtest.json
│ ├── live.json
│ └── optimization.json
├── notebooks/ # Jupyter notebooks
│ ├── research_01.ipynb
│ └── research_02.ipynb
└── main.py # 主入口
16.1.2 库文件组织¶
# library/helpers.py
def CalculatePositionSize(algorithm, symbol, risk_per_trade=0.02):
"""计算仓位大小"""
portfolio_value = algorithm.Portfolio.TotalPortfolioValue
risk_amount = portfolio_value * risk_per_trade
price = algorithm.Securities[symbol].Price
if price > 0:
return int(risk_amount / price)
return 0
def CheckRiskLimits(algorithm, max_drawdown=0.15):
"""检查风险限制"""
portfolio_value = algorithm.Portfolio.TotalPortfolioValue
# 从统计中获取最大回撤(Statistics 只有 TotalPerformance/RollingPerformances/Summary;
# 注意回测过程中该值并非实时最终值,仅在回测结束后才完整,运行中读取仅为中间概念值)
drawdown = algorithm.Statistics.TotalPerformance.PortfolioStatistics.Drawdown
if drawdown > max_drawdown:
algorithm.Error(f"Max drawdown exceeded: {drawdown:.2%}")
algorithm.Liquidate()
return False
return True
# library/statistics.py
def CalculateSharpeRatio(returns, risk_free_rate=0.02):
"""计算夏普比率"""
excess_returns = returns - risk_free_rate / 252
return excess_returns.mean() / excess_returns.std() * np.sqrt(252)
def CalculateSortinoRatio(returns, risk_free_rate=0.02):
"""计算索提诺比率"""
excess_returns = returns - risk_free_rate / 252
downside_returns = returns.copy()
downside_returns[downside_returns > 0] = 0
return excess_returns.mean() / downside_returns.std() * np.sqrt(252)
16.2 基类设计¶
16.2.1 基础策略类¶
# algorithms/base/BaseStrategy.py
from AlgorithmImports import *
class BaseStrategy(QCAlgorithm):
"""
策略基类
提供通用功能:
- 风险管理
- 日志记录
- 数据验证
- 状态管理
"""
def Initialize(self):
"""子类必须实现"""
raise NotImplementedError("Subclasses must implement Initialize()")
def ValidateData(self, data):
"""验证数据有效性"""
if not data.ContainsKey(self.main_symbol):
return False
price = data[self.main_symbol].Price
if price <= 0:
self.Log(f"Invalid price for {self.main_symbol}: {price}")
return False
return True
def CheckRiskLimits(self):
"""检查风险限制"""
# 每日亏损限制
if self.daily_start_value:
current_value = self.Portfolio.TotalPortfolioValue
daily_pnl = (current_value / self.daily_start_value - 1)
if daily_pnl < -self.max_daily_loss:
self.Error(f"Daily loss limit: {daily_pnl:.2%}")
self.Liquidate()
return False
return True
def LogTrade(self, action, details):
"""记录交易日志"""
self.Debug(f"[{self.Time}][{action}] {details}")
# 具体策略继承基类
class MeanReversionStrategy(BaseStrategy):
"""均值回归策略"""
def Initialize(self):
# 设置主符号
self.main_symbol = self.AddEquity("SPY", Resolution.Daily).Symbol
# 风险参数
self.max_daily_loss = 0.02
# 指标
self.rsi = self.RSI(self.main_symbol, 14)
# 调度
self.Schedule.On(
self.DateRules.EveryDay(self.main_symbol),
self.TimeRules.BeforeMarketOpen(self.main_symbol, 30),
lambda: setattr(self, 'daily_start_value', self.Portfolio.TotalPortfolioValue)
)
self.SetWarmUp(TimeSpan.FromDays(30))
def OnData(self, data):
if not self.ValidateData(data):
return
if not self.CheckRiskLimits():
return
# 策略逻辑
if self.rsi.Current.Value < 30:
if not self.Portfolio[self.main_symbol].IsLong:
self.SetHoldings(self.main_symbol, 1)
self.LogTrade("BUY", f"RSI: {self.rsi.Current.Value:.2f}")
elif self.rsi.Current.Value > 70:
if self.Portfolio[self.main_symbol].IsLong:
self.Liquidate(self.main_symbol)
self.LogTrade("SELL", f"RSI: {self.rsi.Current.Value:.2f}")
16.3 设计模式¶
16.3.1 工厂模式¶
class IndicatorFactory:
"""指标工厂"""
@staticmethod
def CreateSMA(algorithm, symbol, period, resolution=Resolution.Daily):
"""创建SMA指标"""
return algorithm.SMA(symbol, period, resolution)
@staticmethod
def CreateRSI(algorithm, symbol, period, movingAverageType=MovingAverageType.Simple):
"""创建RSI指标"""
return algorithm.RSI(symbol, period, movingAverageType)
@staticmethod
def CreateMACD(algorithm, symbol, fast, slow, signal):
"""创建MACD指标"""
return algorithm.MACD(symbol, fast, slow, signal)
class StrategyFactory:
"""策略工厂"""
@staticmethod
def CreateStrategy(strategy_type):
"""创建策略实例"""
strategies = {
'mean_reversion': MeanReversionStrategy,
'momentum': MomentumStrategy,
'arbitrage': ArbitrageStrategy
}
if strategy_type not in strategies:
raise ValueError(f"Unknown strategy type: {strategy_type}")
return strategies[strategy_type]()
16.3.2 策略模式¶
class TradingMode:
"""交易模式"""
AGGRESSIVE = "aggressive"
CONSERVATIVE = "conservative"
BALANCED = "balanced"
class ModeStrategy(QCAlgorithm):
"""根据模式调整参数"""
def Initialize(self):
self.SetStartDate(2020, 1, 1)
self.SetEndDate(2023, 12, 31)
self.SetCash(100000)
# 设置模式
self.trading_mode = TradingMode.BALANCED
# 根据模式设置参数
self.SetModeParameters()
def SetModeParameters(self):
"""根据模式设置参数"""
if self.trading_mode == TradingMode.AGGRESSIVE:
self.position_size = 0.3
self.stop_loss = 0.05
elif self.trading_mode == TradingMode.CONSERVATIVE:
self.position_size = 0.1
self.stop_loss = 0.02
else: # BALANCED
self.position_size = 0.2
self.stop_loss = 0.03
16.4 配置管理¶
16.4.1 配置文件管理¶
# library/config.py
from json import load
from pathlib import Path
class Config:
"""配置管理"""
def __init__(self, config_path="config/strategy_config.json"):
self.config_path = Path(config_path)
self.config = self.LoadConfig()
def LoadConfig(self):
"""加载配置文件"""
if self.config_path.exists():
with open(self.config_path, 'r') as f:
return load(f)
return {}
def Get(self, key, default=None):
"""获取配置值"""
return self.config.get(key, default)
def GetRiskParameters(self):
"""获取风险参数"""
return {
'max_position': self.Get('max_position_size', 0.2),
'stop_loss': self.Get('stop_loss', 0.03),
'take_profit': self.Get('take_profit', 0.06)
}
# 在策略中使用
class ConfigurableStrategy(QCAlgorithm):
"""可配置策略"""
def Initialize(self):
self.config = Config()
# 获取配置参数
risk_params = self.config.GetRiskParameters()
self.max_position = risk_params['max_position']
self.stop_loss = risk_params['stop_loss']
self.take_profit = risk_params['take_profit']
16.5 完整示例:模块化策略¶
from AlgorithmImports import *
# 基础策略
from algorithms.base.BaseStrategy import BaseStrategy
# 工具函数
from library.helpers import CalculatePositionSize, CheckRiskLimits
from library.statistics import CalculateSharpeRatio
# 配置管理
from library.config import Config
class ModularStrategy(BaseStrategy):
"""
模块化策略示例
展示代码组织和设计模式的应用
"""
def __init__(self):
# 策略配置(在进入 Initialize 前即可就绪)
self.config = Config()
def Initialize(self):
"""初始化"""
# 基本设置
self.SetStartDate(2020, 1, 1)
self.SetEndDate(2023, 12, 31)
self.SetCash(100000)
# 添加证券
self.main_symbol = self.AddEquity("SPY", Resolution.Daily).Symbol
# 使用工厂创建指标
self.sma_fast = IndicatorFactory.CreateSMA(self, self.main_symbol, 20)
self.sma_slow = IndicatorFactory.CreateSMA(self, self.main_symbol, 50)
self.rsi = IndicatorFactory.CreateRSI(self, self.main_symbol, 14)
self.SetWarmUp(TimeSpan.FromDays(60))
# 风险参数(读取 self.config 中的配置)
self.risk_params = self.config.GetRiskParameters()
# 状态管理
self.state = {
'current_position': None,
'entry_price': None,
'last_signal': None
}
def OnData(self, data):
"""主数据处理"""
# 数据验证
if not self.ValidateData(data):
return
# 风险检查
if not self.CheckRiskLimits():
return
# 信号生成
signal = self.GenerateSignal()
# 执行交易
self.ExecuteSignal(signal)
def GenerateSignal(self):
"""生成交易信号"""
if not self.sma_fast.IsReady:
return None
# 金叉买入
if (self.sma_fast.Current.Value > self.sma_slow.Current.Value and
self.rsi.Current.Value < 70):
return "BUY"
# 死叉卖出
elif (self.sma_fast.Current.Value < self.sma_slow.Current.Value or
self.rsi.Current.Value > 70):
return "SELL"
return "HOLD"
def ExecuteSignal(self, signal):
"""执行交易信号"""
if signal == "BUY" and self.state['current_position'] != "long":
size = CalculatePositionSize(
self,
self.main_symbol,
self.risk_params.get('position_risk', 0.02)
)
if size > 0:
self.MarketOrder(self.main_symbol, size)
self.state['current_position'] = "long"
self.state['entry_price'] = self.Securities[self.main_symbol].Price
elif signal == "SELL" and self.state['current_position'] == "long":
self.Liquidate(self.main_symbol)
self.state['current_position'] = None
self.state['entry_price'] = None