跳转至

第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