从零学量化｜正期望值、夏普比率、海龟策略全解析

很多刚接触量化交易的人都有一个误区：认为量化就是寻找能够"一夜暴富"的神奇策略。但真正在市场中存活下来的量化交易者都明白一个残酷事实——稳定盈利比暴利更重要。

为什么很多看似收益率惊人的策略最终都会失效？为什么有些策略年化收益率只有15%却能持续盈利10年以上？答案就藏在正期望值、夏普比率和海龟策略这三个核心概念中。本文将用Python代码和真实案例，带你彻底理解量化交易的底层逻辑。

1. 量化交易真正要解决的核心问题

量化交易不是关于"预测市场"的魔法，而是关于"管理风险"的科学。传统投资者往往陷入情绪化交易的陷阱：盈利时过早止盈，亏损时死扛不止损。量化交易通过数学模型和程序化执行，解决了人类决策中的几个关键问题：

情绪干扰问题：人工交易容易受到恐惧、贪婪等情绪影响，导致决策不一致。量化策略一旦回测通过，就会严格按照规则执行。

风险控制缺失：很多散户没有明确的风险管理规则，单次亏损就可能吞噬之前的所有盈利。量化交易强制设定止损点位和仓位管理。

策略可验证性：主观交易难以验证其长期有效性，而量化策略可以通过历史数据回测，计算具体的风险收益指标。

最适合学习量化的人群：

• 有一定Python基础的开发者，想要进入金融科技领域
• 传统投资者希望用系统化方法改进交易效果
• 对数据分析和算法设计感兴趣的技术人员

2. 量化交易三大核心概念解析

2.1 正期望值：策略盈利的数学基础

正期望值（Positive Expected Value）是量化策略能够长期盈利的数学保证。简单来说，就是你的策略在大量交易后，平均每次交易能够赚钱。

期望值计算公式：

期望值 = (胜率 × 平均盈利) - (败率 × 平均亏损)

举个例子：假设一个策略胜率40%，平均盈利300元，平均亏损100元：

期望值 = (0.4 × 300) - (0.6 × 100) = 120 - 60 = 60元

这意味着平均每次交易盈利60元，是正期望值策略。

# 期望值计算函数 def calculate_expected_value(win_rate, avg_profit, avg_loss): """ 计算交易策略的期望值 :param win_rate: 胜率，0-1之间的小数 :param avg_profit: 平均盈利金额 :param avg_loss: 平均亏损金额 :return: 期望值 """ loss_rate = 1 - win_rate expected_value = (win_rate * avg_profit) - (loss_rate * avg_loss) return expected_value # 示例计算 win_rate = 0.4 avg_profit = 300 avg_loss = 100 ev = calculate_expected_value(win_rate, avg_profit, avg_loss) print(f"策略期望值: {ev}元")

期望值的实际意义：不要追求100%胜率，关键是盈利时赚得多，亏损时亏得少。即使胜率只有30%，只要平均盈利是平均亏损的3倍以上，期望值仍然是正的。

2.2 夏普比率：衡量风险调整后的收益

夏普比率（Sharpe Ratio）由诺贝尔奖获得者威廉·夏普提出，是衡量投资"性价比"的重要指标。它告诉我们每承担一单位风险，能获得多少超额收益。

夏普比率计算公式：

夏普比率 = (投资组合收益率 - 无风险利率) / 投资组合收益率的标准差

import numpy as np import pandas as pd def calculate_sharpe_ratio(returns, risk_free_rate=0.03): """ 计算夏普比率 :param returns: 收益率序列，可以是日收益率、月收益率等 :param risk_free_rate: 无风险利率，年化，默认3% :return: 年化夏普比率 """ # 将无风险利率转换为与收益率相同的周期 if len(returns) > 252: # 假设日数据 periods_per_year = 252 else: periods_per_year = 12 # 月数据 excess_returns = returns - (risk_free_rate / periods_per_year) sharpe_ratio = np.sqrt(periods_per_year) * (excess_returns.mean() / returns.std()) return sharpe_ratio # 示例：两个策略的夏普比率对比 np.random.seed(42) # 策略A：高收益高风险 returns_A = np.random.normal(0.0015, 0.03, 252) # 日均收益0.15%，波动3% # 策略B：低收益低风险 returns_B = np.random.normal(0.0008, 0.01, 252) # 日均收益0.08%，波动1% sharpe_A = calculate_sharpe_ratio(returns_A) sharpe_B = calculate_sharpe_ratio(returns_B) print(f"策略A夏普比率: {sharpe_A:.2f}") print(f"策略B夏普比率: {sharpe_B:.2f}")

夏普比率的解读标准：

• 小于1：表现较差，风险调整后收益不理想
• 1-2：不错，每单位风险获得合理回报
• 大于2：优秀，风险收益比很好
• 大于3：极其优秀，但需警惕过拟合

2.3 海龟交易策略：经典趋势跟踪系统

海龟交易策略是量化交易史上最著名的公开策略之一，由理查德·丹尼斯在1983年提出。其核心思想是"抓住大趋势，截断亏损，让利润奔跑"。

海龟策略的四个核心组件：

1. 市场选择：选择流动性好、趋势性强的市场
2. 仓位大小：根据波动率确定仓位，波动大的市场仓位小
3. 入市信号：突破20日或55日最高点买入，突破最低点卖出
4. 退出策略：突破10日最低点平多仓，突破最高点平空仓

class TurtleStrategy: def __init__(self, data, short_window=20, long_window=55, exit_window=10): self.data = data self.short_window = short_window self.long_window = long_window self.exit_window = exit_window def calculate_signals(self): """计算海龟交易信号""" # 计算突破点 self.data['short_high'] = self.data['high'].rolling(window=self.short_window).max() self.data['long_high'] = self.data['high'].rolling(window=self.long_window).max() self.data['short_low'] = self.data['low'].rolling(window=self.short_window).min() self.data['long_low'] = self.data['low'].rolling(window=self.long_window).min() # 计算退出点 self.data['exit_long'] = self.data['low'].rolling(window=self.exit_window).min() self.data['exit_short'] = self.data['high'].rolling(window=self.exit_window).max() # 生成交易信号 self.data['signal'] = 0 # 短期突破买入 self.data.loc[self.data['close'] > self.data['short_high'].shift(1), 'signal'] = 1 # 长期突破买入 self.data.loc[self.data['close'] > self.data['long_high'].shift(1), 'signal'] = 1 # 退出多头 self.data.loc[self.data['close'] < self.data['exit_long'].shift(1), 'signal'] = -1 # 退出空头（简化版，实际海龟策略有空头） return self.data # 使用示例 # 假设data是包含OHLC数据的DataFrame # turtle = TurtleStrategy(data) # signals = turtle.calculate_signals()

3. 量化交易环境准备

3.1 Python环境配置

量化交易需要的基础Python环境：

# 创建虚拟环境 python -m venv quant_env source quant_env/bin/activate # Linux/Mac # 或 quant_env\Scripts\activate # Windows # 安装核心库 pip install numpy pandas matplotlib seaborn pip install jupyter notebook # 可选，用于数据分析

3.2 金融数据获取库

# 安装金融数据相关库 pip install yfinance # 雅虎财经数据 pip install akshare # 国内金融数据 pip install tushare # 国内股票数据（需要token）

3.3 回测框架安装

# 安装回测框架 pip install backtrader # 功能强大的回测框架 pip install zipline # 量化回测库

3.4 开发环境建议

• IDE：VS Code + Python插件，或PyCharm
• 数据存储：SQLite（小型项目）、MySQL（中型项目）
• 版本控制：Git + GitHub/GitLab
• 文档工具：Jupyter Notebook用于策略研究

4. 正期望值策略实战开发

4.1 均值回归策略实现

均值回归策略基于"价格围绕价值波动"的原理，在价格偏离均值时反向交易。

import yfinance as yf import pandas as pd import numpy as np class MeanReversionStrategy: def __init__(self, symbol, window=20, z_threshold=2.0): self.symbol = symbol self.window = window self.z_threshold = z_threshold def download_data(self, period="1y"): """下载股票数据""" self.data = yf.download(self.symbol, period=period) return self.data def calculate_zscore(self): """计算Z-score指标""" self.data['returns'] = self.data['Close'].pct_change() self.data['mean'] = self.data['Close'].rolling(window=self.window).mean() self.data['std'] = self.data['Close'].rolling(window=self.window).std() self.data['zscore'] = (self.data['Close'] - self.data['mean']) / self.data['std'] return self.data def generate_signals(self): """生成交易信号""" self.data['signal'] = 0 # Z-score低于阈值，买入信号（价格低于均值） self.data.loc[self.data['zscore'] < -self.z_threshold, 'signal'] = 1 # Z-score高于阈值，卖出信号（价格高于均值） self.data.loc[self.data['zscore'] > self.z_threshold, 'signal'] = -1 return self.data def backtest(self): """简单回测""" self.data['position'] = self.data['signal'].shift(1) self.data['strategy_returns'] = self.data['position'] * self.data['returns'] # 计算累计收益 self.data['cumulative_market'] = (1 + self.data['returns']).cumprod() self.data['cumulative_strategy'] = (1 + self.data['strategy_returns']).cumprod() return self.data # 使用示例 strategy = MeanReversionStrategy('AAPL') data = strategy.download_data() data = strategy.calculate_zscore() data = strategy.generate_signals() results = strategy.backtest() print(f"策略最终收益: {results['cumulative_strategy'].iloc[-1]:.2f}") print(f"市场最终收益: {results['cumulative_market'].iloc[-1]:.2f}")

4.2 策略期望值分析

def analyze_strategy_performance(strategy_returns): """分析策略性能""" # 计算胜率 winning_trades = len(strategy_returns[strategy_returns > 0]) total_trades = len(strategy_returns[strategy_returns != 0]) win_rate = winning_trades / total_trades if total_trades > 0 else 0 # 计算平均盈利和平均亏损 avg_profit = strategy_returns[strategy_returns > 0].mean() if winning_trades > 0 else 0 avg_loss = strategy_returns[strategy_returns < 0].mean() if (total_trades - winning_trades) > 0 else 0 # 计算期望值 expected_value = calculate_expected_value(win_rate, avg_profit, abs(avg_loss)) # 计算夏普比率 sharpe = calculate_sharpe_ratio(strategy_returns) print(f"胜率: {win_rate:.2%}") print(f"平均盈利: {avg_profit:.4%}") print(f"平均亏损: {avg_loss:.4%}") print(f"期望值: {expected_value:.6f}") print(f"夏普比率: {sharpe:.2f}") return { 'win_rate': win_rate, 'avg_profit': avg_profit, 'avg_loss': avg_loss, 'expected_value': expected_value, 'sharpe_ratio': sharpe } # 分析均值回归策略 strategy_returns = results['strategy_returns'].dropna() performance = analyze_strategy_performance(strategy_returns)

5. 夏普比率的深入应用与优化

5.1 多时间框架夏普比率分析

夏普比率在不同时间框架下会有显著差异，需要综合分析：

def multi_timeframe_sharpe_analysis(data, symbol): """多时间框架夏普比率分析""" timeframes = { '日线': data, '周线': data.resample('W').last(), '月线': data.resample('M').last() } results = {} for timeframe, tf_data in timeframes.items(): returns = tf_data['Close'].pct_change().dropna() sharpe = calculate_sharpe_ratio(returns) # 计算最大回撤 cumulative = (1 + returns).cumprod() peak = cumulative.expanding().max() drawdown = (cumulative - peak) / peak max_drawdown = drawdown.min() results[timeframe] = { 'sharpe_ratio': sharpe, 'max_drawdown': max_drawdown, 'annual_return': returns.mean() * 252 if timeframe == '日线' else returns.mean() * 12 } return pd.DataFrame(results).T # 执行多时间框架分析 tf_analysis = multi_timeframe_sharpe_analysis(data, 'AAPL') print(tf_analysis)

5.2 夏普比率优化实战

通过参数优化提升夏普比率：

from sklearn.model_selection import ParameterGrid def optimize_strategy_parameters(data, param_grid): """优化策略参数以最大化夏普比率""" best_sharpe = -np.inf best_params = None best_returns = None for params in ParameterGrid(param_grid): # 应用参数运行策略 strategy = MeanReversionStrategy('AAPL', window=params['window'], z_threshold=params['z_threshold']) strategy.data = data.copy() strategy.calculate_zscore() strategy.generate_signals() strategy.backtest() returns = strategy.data['strategy_returns'].dropna() if len(returns) > 0: sharpe = calculate_sharpe_ratio(returns) if sharpe > best_sharpe: best_sharpe = sharpe best_params = params best_returns = returns return best_params, best_sharpe, best_returns # 定义参数网格 param_grid = { 'window': [10, 20, 30, 50], 'z_threshold': [1.5, 2.0, 2.5, 3.0] } # 执行参数优化 best_params, best_sharpe, best_returns = optimize_strategy_parameters(data, param_grid) print(f"最优参数: {best_params}") print(f"最优夏普比率: {best_sharpe:.2f}")

6. 完整海龟策略实现与回测

6.1 完整版海龟交易系统

import backtrader as bt class TurtleStrategyBT(bt.Strategy): params = ( ('long_window', 55), ('short_window', 20), ('exit_window', 10), ('atr_period', 20), ('risk_per_trade', 0.02) # 每笔交易风险2% ) def __init__(self): # 计算突破点 self.long_high = bt.indicators.Highest(self.data.high, period=self.params.long_window) self.short_high = bt.indicators.Highest(self.data.high, period=self.params.short_window) self.long_low = bt.indicators.Lowest(self.data.low, period=self.params.long_window) self.short_low = bt.indicators.Lowest(self.data.low, period=self.params.short_window) # 计算ATR用于仓位管理 self.atr = bt.indicators.ATR(self.data, period=self.params.atr_period) # 退出点 self.exit_long = bt.indicators.Lowest(self.data.low, period=self.params.exit_window) self.exit_short = bt.indicators.Highest(self.data.high, period=self.params.exit_window) self.order = None def next(self): if self.order: return # 有未完成订单，等待 # 计算仓位大小 price = self.data.close[0] atr_value = self.atr[0] if atr_value > 0: # 根据ATR计算仓位，确保每笔交易风险可控 risk_amount = self.broker.getvalue() * self.params.risk_per_trade size = int(risk_amount / atr_value) else: size = 100 # 默认仓位 # 生成交易信号 if not self.position: # 没有持仓，检查买入信号 if price > self.long_high[-1] or price > self.short_high[-1]: self.order = self.buy(size=size) print(f'买入信号: 价格{price:.2f}, 仓位{size}') else: # 有持仓，检查退出信号 if price < self.exit_long[-1]: self.order = self.sell() print(f'退出信号: 价格{price:.2f}')

6.2 海龟策略回测执行

def run_turtle_backtest(symbol, start_date, end_date, initial_cash=100000): """运行海龟策略回测""" cerebro = bt.Cerebro() # 添加策略 cerebro.addstrategy(TurtleStrategyBT) # 加载数据 data = bt.feeds.YahooFinanceData( dataname=symbol, fromdate=start_date, todate=end_date ) cerebro.adddata(data) # 设置资金 cerebro.broker.setcash(initial_cash) # 设置手续费 cerebro.broker.setcommission(commission=0.001) # 0.1%手续费 # 添加分析器 cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe') cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown') cerebro.addanalyzer(bt.analyzers.Returns, _name='returns') # 运行回测 results = cerebro.run() strategy = results[0] # 打印结果 sharpe = strategy.analyzers.sharpe.get_analysis() drawdown = strategy.analyzers.drawdown.get_analysis() returns = strategy.analyzers.returns.get_analysis() print("=== 海龟策略回测结果 ===") print(f"初始资金: {initial_cash:,.2f}") print(f"最终资金: {cerebro.broker.getvalue():,.2f}") print(f"总收益率: {returns['rtot']:.2%}") print(f"年化收益率: {returns['rnorm100']:.2f}%") print(f"夏普比率: {sharpe['sharperatio']:.2f}") print(f"最大回撤: {drawdown['max']['drawdown']:.2%}") # 绘制图表 cerebro.plot() return cerebro.broker.getvalue() # 执行回测（示例代码，实际运行需要真实数据） # final_value = run_turtle_backtest('AAPL', datetime(2020, 1, 1), datetime(2023, 12, 31))

7. 量化交易常见问题与解决方案

7.1 策略过拟合问题

过拟合是量化交易中最常见的问题，表现为在历史数据上表现优异，但在实盘中表现糟糕。

过拟合的识别方法：

• 策略参数过于复杂，轻微调整参数性能急剧下降
• 在样本外数据（Out-of-Sample）上表现远差于样本内数据（In-Sample）
• 交易信号过于频繁，可能拟合了噪声而非真实规律

解决方案：

def avoid_overfitting(train_data, test_data, param_grid): """通过交叉验证避免过拟合""" train_results = [] test_results = [] for params in ParameterGrid(param_grid): # 训练集表现 train_strategy = MeanReversionStrategy('AAPL', **params) train_strategy.data = train_data.copy() # ...运行策略计算夏普比率 train_sharpe = calculate_sharpe_ratio(train_strategy.data['strategy_returns'].dropna()) # 测试集表现 test_strategy = MeanReversionStrategy('AAPL', **params) test_strategy.data = test_data.copy() # ...运行策略计算夏普比率 test_sharpe = calculate_sharpe_ratio(test_strategy.data['strategy_returns'].dropna()) train_results.append(train_sharpe) test_results.append(test_sharpe) # 选择在测试集上表现稳定的参数 performance_gap = np.array(train_results) - np.array(test_results) # 选择性能差距小的参数 best_idx = np.argmin(np.abs(performance_gap)) return list(ParameterGrid(param_grid))[best_idx]

7.2 夏普比率失真问题

夏普比率在某些情况下可能失真，需要结合其他指标综合判断：

def comprehensive_performance_analysis(returns): """综合性能分析""" # 基础指标 sharpe = calculate_sharpe_ratio(returns) # 最大回撤 cumulative = (1 + returns).cumprod() peak = cumulative.expanding().max() drawdown = (cumulative - peak) / peak max_drawdown = drawdown.min() # Calmar比率（年化收益/最大回撤） annual_return = returns.mean() * 252 calmar = annual_return / abs(max_drawdown) if max_drawdown != 0 else np.nan # 索提诺比率（只考虑下行风险） downside_returns = returns[returns < 0] sortino = annual_return / downside_returns.std() / np.sqrt(252) if len(downside_returns) > 0 else np.nan print(f"夏普比率: {sharpe:.2f}") print(f"最大回撤: {max_drawdown:.2%}") print(f"Calmar比率: {calmar:.2f}") print(f"索提诺比率: {sortino:.2f}")

7.3 实盘交易中的技术问题

数据质量问题：

• 使用多个数据源交叉验证
• 处理缺失值和异常值
• 注意除权除息调整

交易执行问题：

• 考虑滑点（Slippage）影响
• 处理限价单未成交情况
• 监控API调用频率限制

风险监控问题：

• 实时监控策略表现
• 设置自动止损机制
• 定期重新评估策略有效性

8. 量化交易最佳实践与工程建议

8.1 策略开发流程标准化

建立科学的策略开发流程：

1. 想法产生：基于市场观察或学术研究
2. 数据准备：获取清洗好的历史数据
3. 策略实现：用代码实现交易逻辑
4. 回测验证：在历史数据上测试
5. 参数优化：寻找最优参数组合
6. 样本外测试：验证策略稳健性
7. 模拟交易：在真实市场环境中测试
8. 实盘交易：小资金开始，逐步放大

8.2 风险管理系统设计

class RiskManagementSystem: def __init__(self, max_drawdown_limit=0.2, daily_loss_limit=0.05): self.max_drawdown_limit = max_drawdown_limit self.daily_loss_limit = daily_loss_limit self.peak_equity = 0 self.daily_equity = 0 def check_risk_limits(self, current_equity, date): """检查风险限制""" # 更新峰值权益 if current_equity > self.peak_equity: self.peak_equity = current_equity # 计算当前回撤 drawdown = (self.peak_equity - current_equity) / self.peak_equity # 检查日亏损限制（简化版） if self.daily_equity == 0: self.daily_equity = current_equity daily_return = (current_equity - self.daily_equity) / self.daily_equity violations = [] if drawdown > self.max_drawdown_limit: violations.append(f"最大回撤超限: {drawdown:.2%} > {self.max_drawdown_limit:.2%}") if daily_return < -self.daily_loss_limit: violations.append(f"日亏损超限: {daily_return:.2%} < -{self.daily_loss_limit:.2%}") # 每日重置日权益 # 实际中应该按交易日重置 return violations def should_stop_trading(self, violations): """根据违规情况决定是否停止交易""" return len(violations) > 0

8.3 代码质量与可维护性

策略代码规范：

• 使用面向对象设计，便于策略复用和扩展
• 清晰的文档字符串和类型提示
• 单元测试覆盖核心逻辑
• 配置与代码分离，便于参数调整

日志记录规范：

import logging def setup_logging(): """设置量化交易日志系统""" logger = logging.getLogger('quant_trading') logger.setLevel(logging.INFO) # 文件处理器 file_handler = logging.FileHandler('trading.log') file_handler.setLevel(logging.INFO) # 控制台处理器 console_handler = logging.StreamHandler() console_handler.setLevel(logging.WARNING) # 格式器 formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) file_handler.setFormatter(formatter) console_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.addHandler(console_handler) return logger # 使用日志 logger = setup_logging() logger.info("策略开始运行") logger.warning("检测到异常价格波动")

9. 从理论到实践的完整路径

量化交易的学习是一个循序渐进的过程，建议按以下路径推进：

第一阶段：基础掌握（1-2个月）

• 学习Python金融数据分析基础
• 理解正期望值、夏普比率等核心概念
• 实现简单的移动平均线策略

第二阶段：策略开发（2-3个月）

• 学习经典策略如海龟交易系统、均值回归
• 掌握回测框架的使用
• 学会参数优化和过拟合识别

第三阶段：实盘经验（3-6个月）

• 从小资金开始模拟交易
• 建立风险管理和资金管理体系
• 积累实盘问题处理经验

第四阶段：系统优化（持续进行）

• 开发多策略组合
• 优化执行效率和成本
• 建立自动化监控系统

记住量化交易的核心原则：风险控制优先于收益追求，稳定性优于爆发性。一个年化15%但最大回撤只有5%的策略，长期来看远比年化50%但最大回撤30%的策略更有价值。

真正的量化交易高手不是预测大师，而是风险管理专家。通过本文介绍的正期望值、夏普比率和海龟策略这三个核心工具，你已经掌握了量化交易的基础框架。接下来需要的是实践、反思和持续改进。