Python 量化交易:从理论到实盘
文中策略只用来解释机制,不构成任何投资建议:回测好看不等于实盘能赚钱,滑点、手续费、容量和过拟合这四关,比策略本身更容易让人亏钱。
目录
- 零、金融市场基础理论
- 一、量化交易基础
- 二、统计学与概率论基础
- 三、数据获取与处理
- 四、技术指标与策略开发
- 五、回测框架 Backtrader
- 六、风险管理理论与实践
- 七、策略优化与参数调优
- 八、实盘交易对接
- 九、进阶策略
- 十、监控与运维
- 十一、最佳实践
零、金融市场基础理论
学习目标:理解证券市场运作原理、价格形成机制、收益与风险的本质
0.1 证券市场基本概念
0.1.1 什么是股票?
股票(Stock) 是股份公司发行的所有权凭证。持有股票意味着:
- 所有权:成为公司的股东,享有公司利润分配权
- 收益权:通过股息(分红)和资本利得(价差)获利
- 投票权:参与公司重大决策
- 有限责任:最大损失为投资本金
股票价格的影响因素:
股票价格 = f(公司基本面, 市场情绪, 宏观经济, 行业趋势, 资金流动)- 基本面:盈利能力、成长性、财务健康度
- 市场情绪:投资者信心、恐慌指数
- 宏观经济:GDP增长、利率、通胀
- 行业趋势:政策导向、技术变革
- 资金流动:北向资金、机构持仓
0.1.2 交易机制
A股交易规则:
| 要素 | 规则 |
|---|---|
| 交易时间 | 9:30-11:30, 13:00-15:00 |
| 涨跌幅限制 | 主板±10%,科创板/创业板±20%,ST股票±5%,北交所±30% |
| 最小交易单位 | 1手 = 100股 |
| 交易费用 | 佣金(万2.5-万3)+ 印花税(0.05%,仅卖出)+ 过户费(0.001%) |
| T+1制度 | 当天买入的股票次日才能卖出 |
订单类型:
- 市价单(Market Order):以当前最优价格立即成交
- 限价单(Limit Order):指定价格,价格达到时成交
- 止损单(Stop Order):价格触及止损线时自动卖出
0.1.3 K线图基础
K线(蜡烛图) 是记录价格变动的图表,每根K线包含四个价格:
最高价 ─┐
│ ┌─ 实体(开盘价和收盘价之间)
收盘价 ─┤ │ - 红色/阳线:收盘价 > 开盘价(上涨)
开盘价 ─┘ │ - 绿色/阴线:收盘价 < 开盘价(下跌)
│ └─ 影线(最高/最低价的延伸)
最低价 ─┘常见K线形态的含义:
| 形态 | 特征 | 含义 |
|---|---|---|
| 大阳线 | 长实体,几乎没有上下影线 | 强烈上涨信号 |
| 大阴线 | 长实体,几乎没有上下影线 | 强烈下跌信号 |
| 十字星 | 开盘价≈收盘价,有上下影线 | 趋势可能反转 |
| 锤子线 | 小实体,长下影线 | 底部反转信号 |
| 流星线 | 小实体,长上影线 | 顶部反转信号 |
0.2 价格形成机制
0.2.1 供需理论
股票价格由供给和需求决定:
- 需求增加 → 买盘强劲 → 价格上涨
- 供给增加 → 卖盘压力 → 价格下跌
影响供需的因素:
需求因素:
├─ 企业盈利预期上升
├─ 行业景气度提升
├─ 市场流动性充裕(降息、宽松政策)
└─ 投资者信心增强
供给因素:
├─ 限售股解禁
├─ 大股东减持
├─ IPO/增发扩容
└─ 投资者恐慌性抛售0.2.2 价格发现过程
交易所通过连续竞价实现价格发现:
- 集合竞价(9:15-9:25):所有订单汇总,按"价格优先、时间优先"原则撮合
- 连续竞价(9:30-15:00):实时撮合买卖订单
成交原则:
买入订单:价格从高到低排列
卖出订单:价格从低到高排列
成交价 = 使成交量最大的价格0.3 市场有效性假说
0.3.1 有效市场假说(EMH)
核心观点:市场价格已经充分反映了所有可获得的信息。
三种形态:
| 形态 | 信息范围 | 推论 | 对量化交易的启示 |
|---|---|---|---|
| 弱式有效 | 历史价格 | 技术分析无效 | 需要结合其他信息 |
| 半强式有效 | 公开信息 | 基本面分析无效 | 寻找信息优势 |
| 强式有效 | 所有信息(含内幕) | 任何分析都无效 | 市场并非完全有效 |
实际情况:
- 市场并非完全有效,存在:
- 信息不对称:散户vs机构投资者
- 行为偏差:羊群效应、过度反应、损失厌恶
- 流动性差异:大盘股vs小盘股
- 交易摩擦:手续费、滑点、冲击成本
0.3.2 行为金融学
人性弱点影响决策:
| 偏差 | 表现 | 对交易的影响 |
|---|---|---|
| 损失厌恶 | 亏损的痛苦 > 盈利的快乐 | 过早止盈、死守亏损 |
| 过度自信 | 高估自己的判断能力 | 过度交易、忽视风险 |
| 锚定效应 | 过度依赖初始信息 | 无法适应市场变化 |
| 羊群效应 | 跟随大众决策 | 追涨杀跌 |
| 确认偏差 | 只看支持自己观点的信息 | 忽视风险信号 |
量化交易的优势:用程序化交易消除情绪干扰。
0.4 收益与风险的量化
0.4.1 收益率的计算
简单收益率(Simple Return):
对数收益率(Log Return):
为什么用对数收益率?
优势:
- 可加性:多期收益 = 各期对数收益之和
- 时间可比性:不同时间段收益率可直接比较
- 统计性质好:更接近正态分布
import numpy as np
import pandas as pd
## 计算收益率
prices = pd.Series([100, 102, 105, 103, 108])
## 简单收益率
simple_return = prices.pct_change()
print("简单收益率:", simple_return)
## 对数收益率
log_return = np.log(prices / prices.shift(1))
print("对数收益率:", log_return)
## 累计收益
cumulative_return = (1 + simple_return).cumprod() - 1
print("累计收益率:", cumulative_return.iloc[-1])0.4.2 风险的度量
波动率(Volatility): 收益率的标准差
年化波动率:
(A股每年约252个交易日)
## 计算波动率
returns = df['close'].pct_change().dropna()
## 日波动率
daily_vol = returns.std()
## 年化波动率
annual_vol = daily_vol * np.sqrt(252)
print(f"日波动率: {daily_vol:.4f}")
print(f"年化波动率: {annual_vol:.2%}")其他风险指标:
| 指标 | 公式 | 含义 |
|---|---|---|
| VaR(风险价值) | α置信度下的最大损失 | |
| CVaR(条件VaR) | 超过VaR时的平均损失 | |
| 下行波动率 | 只计算负收益的波动 | 更关注下跌风险 |
一、量化交易基础
1.1 什么是量化交易?
定义:将交易逻辑转化为计算机程序,利用数学模型和统计方法自动执行买卖决策。
量化交易 vs 主观交易:
| 维度 | 量化交易 | 主观交易 |
|---|---|---|
| 决策依据 | 数学模型、统计规律 | 经验、直觉、盘感 |
| 执行方式 | 程序自动化 | 人工手动操作 |
| 情绪影响 | 无情绪干扰 | 易受恐惧/贪婪影响 |
| 可回溯性 | 可用历史数据验证 | 难以量化验证 |
| 适应性 | 需重新编程 | 灵活应变 |
| 交易频率 | 可高频(毫秒级) | 低频(分钟/小时级) |
核心优势:
- 消除情绪干扰:避免"追涨杀跌"、"死扛亏损"等人性弱点
- 可验证性:用历史数据检验策略有效性(回测)
- 执行纪律性:严格按规则操作,不受市场情绪影响
- 高效处理信息:同时监控数百个标的,捕捉稍纵即逝的机会
- 风险可控:预设止损止盈,最大回撤可量化
量化交易流程:
┌──────────────────────────────────────────────────────┐
│ 量化交易完整流程 │
└──────────────────────────────────────────────────────┘
│
├─→ 1. 理论假设
│ └─ 市场存在某种可预测的规律(均值回归、动量效应等)
│
├─→ 2. 数据获取
│ └─ 历史价格、成交量、财务数据、宏观指标
│
├─→ 3. 特征工程
│ └─ 计算技术指标、提取统计特征
│
├─→ 4. 策略开发
│ └─ 将假设转化为可执行的交易规则
│
├─→ 5. 历史回测
│ └─ 用过去数据验证策略的有效性
│ ├─ 收益率如何?
│ ├─ 最大回撤多大?
│ ├─ 胜率和盈亏比?
│ └─ 是否过拟合?
│
├─→ 6. 参数优化
│ └─ 寻找最优参数组合(避免过度拟合)
│
├─→ 7. 样本外测试
│ └─ 用未参与优化的数据进行验证
│
├─→ 8. 模拟盘验证
│ └─ 小资金实盘测试,观察滑点、冲击成本
│
└─→ 9. 实盘交易
└─ 持续监控、定期评估、动态调整1.2 技术分析的理论基础
1.2.1 技术分析三大假设
假设一:市场行为包容一切
- 价格已反映所有信息(基本面、政策、情绪)
- 只需分析价格和成交量,无需关注"为什么涨跌"
假设二:价格沿趋势移动
- 趋势一旦形成,倾向于延续(牛顿第一定律:惯性)
- 趋势反转需要强大的外力(政策、黑天鹅事件)
假设三:历史会重演
- 人性不变 → 行为模式重复 → 价格形态重现
- K线形态、支撑阻力位具有参考价值
争议与局限性:
| 批评观点 | 反驳 |
|---|---|
| 历史数据无法预测未来 | 统计规律在大样本下有效 |
| 市场是随机游走的 | 存在短期动量和长期均值回归 |
| 自我实现的预言 | 部分成立,但不影响策略盈利 |
1.2.2 趋势理论
道氏理论(Dow Theory): 最早的技术分析理论
核心观点:
市场有三种趋势:
- 主要趋势(1年以上):牛市/熊市
- 次要趋势(3周-3个月):主趋势的回调
- 短期波动(少于3周):市场噪音
趋势的三个阶段:
牛市阶段: ├─ 累积期:聪明资金布局,成交量低 ├─ 上涨期:大众跟进,成交量放大 └─ 派发期:主力出货,散户接盘 熊市阶段: ├─ 派发期:高位震荡,主力出货 ├─ 恐慌期:加速下跌,成交量放大 └─ 筑底期:跌无可跌,成交量萎缩价格与成交量的关系:
- 健康上涨:价涨量增(量价齐升)
- 虚假上涨:价涨量缩(拉高出货)
- 健康下跌:价跌量缩(抛压减轻)
- 恐慌下跌:价跌量增(恐慌性抛售)
1.2.3 支撑与阻力
定义:
- 支撑位(Support):价格下跌遇到强劲买盘,难以跌破的价格区域
- 阻力位(Resistance):价格上涨遇到强劲卖盘,难以突破的价格区域
形成原因:
| 类型 | 原理 | 示例 |
|---|---|---|
| 心理关口 | 整数价位(如50元、100元) | 投资者心理定价 |
| 历史高点 | 前期高点的卖压 | 解套盘涌出 |
| 均线支撑 | MA成为动态支撑/阻力 | 60日均线 |
| 缺口 | 跳空缺口形成阻力 | 填权/填息 |
突破的确认:
真突破:
├─ 放量突破(成交量明显放大)
├─ 突破幅度 > 3%
└─ 连续3天站稳
假突破(Bull Trap/Bear Trap):
├─ 缩量突破
├─ 突破后快速回落
└─ 诱多/诱空陷阱1.3 量化交易的数学基础
1.3.1 时间序列的基本概念
时间序列(Time Series):按时间顺序排列的数据点序列。
重要性质:
平稳性(Stationarity):
- 均值、方差、自协方差不随时间变化
- 大多数统计模型要求数据平稳
检验方法:ADF检验(Augmented Dickey-Fuller Test)
from statsmodels.tsa.stattools import adfuller # 检验序列是否平稳 result = adfuller(df['close']) print(f"ADF统计量: {result[0]}") print(f"p值: {result[1]}") print(f"是否平稳: {'是' if result[1] < 0.05 else '否'}")自相关性(Autocorrelation):
- 序列与其滞后值之间的相关性
- 用于判断是否存在趋势/周期
公式:
from statsmodels.graphics.tsaplots import plot_acf import matplotlib.pyplot as plt # 绘制自相关图 plot_acf(df['close'], lags=40) plt.show()
1.3.2 随机游走与均值回归
随机游走(Random Walk):
- 价格变化完全随机,无法预测
- 符合"弱式有效市场假说"
均值回归(Mean Reversion):
- 价格偏离均值后会回归
- 接近0:快速回归;接近1:缓慢回归
实际情况:
- 短期(分钟/小时):随机游走为主
- 中期(天/周):动量效应(趋势延续)
- 长期(月/年):均值回归
检验均值回归:
from statsmodels.tsa.stattools import coint
## 协整检验(检验两个股票是否存在均值回归关系)
stock1 = df1['close']
stock2 = df2['close']
score, pvalue, _ = coint(stock1, stock2)
if pvalue < 0.05:
print("存在协整关系,可进行配对交易")
else:
print("不存在协整关系")1.3.3 风险与收益的权衡
马科维茨投资组合理论(Modern Portfolio Theory, MPT):
核心思想:通过分散化投资降低风险。
有效前沿(Efficient Frontier):
收益率
↑
│ ● ← 最优组合(夏普比率最高)
│ ●●●
│ ●●●●●
│ ●●●●●●●
│●●●●●●●●●
└──────────→ 风险(标准差)夏普比率(Sharpe Ratio): 衡量风险调整后收益
- :组合预期收益率
- :无风险利率(如国债利率)
- :组合标准差
含义:每承担1单位风险,获得多少超额收益。
def calculate_sharpe(returns, risk_free_rate=0.03):
"""
计算夏普比率
Args:
returns: 收益率序列
risk_free_rate: 年化无风险利率
"""
# 年化收益率
annual_return = returns.mean() * 252
# 年化波动率
annual_vol = returns.std() * np.sqrt(252)
# 夏普比率
sharpe = (annual_return - risk_free_rate) / annual_vol
return sharpe
## 使用
returns = df['close'].pct_change()
sharpe = calculate_sharpe(returns)
print(f"夏普比率: {sharpe:.2f}")二、统计学与概率论基础
学习目标:掌握量化交易中常用的统计方法和概率分布
2.1 描述性统计
2.1.1 集中趋势
均值(Mean): 所有数据的平均值
中位数(Median): 排序后位于中间的值(50%分位数)
众数(Mode): 出现频率最高的值
为什么不只用均值?
- 均值受极端值影响大(outlier敏感)
- 中位数更稳健(robust)
import numpy as np
returns = df['close'].pct_change().dropna()
print(f"均值: {returns.mean():.4f}")
print(f"中位数: {returns.median():.4f}")
print(f"50%分位数: {returns.quantile(0.5):.4f}") # 与中位数相同2.1.2 离散程度
方差(Variance): 衡量数据分散程度
标准差(Standard Deviation): 方差的平方根
变异系数(CV): 相对离散程度
四分位距(IQR): 25%分位数与75%分位数之差
## 计算离散程度指标
print(f"标准差: {returns.std():.4f}")
print(f"方差: {returns.var():.6f}")
print(f"25%分位数: {returns.quantile(0.25):.4f}")
print(f"75%分位数: {returns.quantile(0.75):.4f}")
print(f"IQR: {returns.quantile(0.75) - returns.quantile(0.25):.4f}")2.1.3 分布形态
偏度(Skewness): 衡量分布的对称性
- Skew > 0:右偏(正偏),长尾在右侧
- Skew < 0:左偏(负偏),长尾在左侧
- Skew = 0:对称分布(如正态分布)
峰度(Kurtosis): 衡量分布的尖峭程度
- Kurt > 0:厚尾分布(Leptokurtic),极端值出现概率高
- Kurt < 0:薄尾分布(Platykurtic)
- Kurt = 0:正态分布
from scipy import stats
## 计算偏度和峰度
skew = stats.skew(returns)
kurt = stats.kurtosis(returns)
print(f"偏度: {skew:.2f}")
print(f"峰度: {kurt:.2f}")
if skew > 0:
print("→ 收益率分布右偏,大涨天数较多")
elif skew < 0:
print("→ 收益率分布左偏,大跌天数较多")
if kurt > 0:
print("→ 厚尾分布,黑天鹅事件概率高于正态分布")2.2 概率分布
2.2.1 正态分布(Normal Distribution)
概率密度函数:
特性:
- 68%的数据在 范围内
- 95%的数据在 范围内
- 99.7%的数据在 范围内
在金融中的应用:
- 收益率近似服从正态分布(实际上是厚尾分布)
- VaR计算、期权定价(Black-Scholes模型)
import matplotlib.pyplot as plt
from scipy.stats import norm
## 检验收益率是否服从正态分布
mu = returns.mean()
sigma = returns.std()
## Q-Q图(Quantile-Quantile Plot)
stats.probplot(returns, dist="norm", plot=plt)
plt.title("Q-Q图: 检验正态性")
plt.show()
## Shapiro-Wilk 正态性检验
stat, p_value = stats.shapiro(returns)
print(f"Shapiro-Wilk 检验 p值: {p_value:.4f}")
print(f"是否服从正态分布: {'否' if p_value < 0.05 else '是'}")2.2.2 学生t分布(Student's t-Distribution)
特点:
- 比正态分布更厚的尾部
- 更适合描述金融收益率(极端值多)
- 自由度越大,越接近正态分布
from scipy.stats import t
## 拟合t分布
params = t.fit(returns)
df_t = params[0] # 自由度
print(f"t分布自由度: {df_t:.2f}")
print(f"自由度 < 30,说明存在明显厚尾特征")2.3 假设检验
2.3.1 t检验
目的:检验策略收益率是否显著 > 0
原假设(H0):(策略无效)
备择假设(H1):(策略有效)
from scipy.stats import ttest_1samp
## 单样本t检验
t_stat, p_value = ttest_1samp(returns, 0)
print(f"t统计量: {t_stat:.4f}")
print(f"p值: {p_value:.4f}")
if p_value < 0.05:
print("✅ 拒绝原假设,策略收益显著 > 0")
else:
print("❌ 无法拒绝原假设,策略可能无效")2.3.2 相关性检验
皮尔逊相关系数(Pearson Correlation):
- :完全正相关
- :无线性相关
- :完全负相关
## 计算两只股票的相关性
corr = df1['close'].corr(df2['close'])
print(f"相关系数: {corr:.4f}")
## 相关性矩阵(多只股票)
stocks = pd.DataFrame({
'stock1': df1['close'],
'stock2': df2['close'],
'stock3': df3['close']
})
corr_matrix = stocks.corr()
print(corr_matrix)
## 可视化相关性矩阵
import seaborn as sns
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm')
plt.show()2.4 时间序列分析
2.4.1 移动平均(Moving Average, MA)
简单移动平均(SMA):
指数移动平均(EMA):
其中
区别:
- SMA:所有数据权重相同
- EMA:近期数据权重更大,响应更快
## 计算移动平均
df['SMA20'] = df['close'].rolling(20).mean()
df['EMA20'] = df['close'].ewm(span=20, adjust=False).mean()
## 绘图对比
df[['close', 'SMA20', 'EMA20']].plot(figsize=(12, 6))
plt.title("SMA vs EMA")
plt.show()2.4.2 自回归模型(AR)
定义: 用过去的值预测未来
- :阶数(使用过去p期数据)
- :自回归系数
from statsmodels.tsa.ar_model import AutoReg
## 拟合AR模型
model = AutoReg(df['close'], lags=5)
result = model.fit()
## 预测未来5天
forecast = result.predict(start=len(df), end=len(df)+4)
print("未来5天预测:", forecast)三、数据获取与处理
2.1 数据源对比
| 数据源 | 市场覆盖 | 免费额度 | 延迟 | 推荐场景 |
|---|---|---|---|---|
| Tushare | A股 | 免费有限制 | T+1 | 中国股票 |
| AkShare | 全球 | 完全免费 | 实时 | 快速原型 |
| yfinance | 美股 | 完全免费 | 实时 | 美股研究 |
| Baostock | A股 | 完全免费 | T+1 | 历史数据 |
| TqSdk | 期货 | 需账户 | 毫秒级 | 期货实盘 |
2.2 使用 AkShare 获取数据
pip install akshare获取股票数据:
import akshare as ak
import pandas as pd
from datetime import datetime, timedelta
def get_stock_data(stock_code: str, start_date: str = None, end_date: str = None) -> pd.DataFrame:
"""
获取股票历史数据
Args:
stock_code: 股票代码,如 '000001'
start_date: 开始日期 'YYYYMMDD'
end_date: 结束日期 'YYYYMMDD'
Returns:
DataFrame 包含 OHLCV 数据
"""
if start_date is None:
start_date = (datetime.now() - timedelta(days=365)).strftime('%Y%m%d')
if end_date is None:
end_date = datetime.now().strftime('%Y%m%d')
# 获取 A 股数据
df = ak.stock_zh_a_hist(
symbol=stock_code,
period="daily",
start_date=start_date,
end_date=end_date,
adjust="qfq" # 前复权
)
# 重命名列
df = df.rename(columns={
'日期': 'date',
'开盘': 'open',
'最高': 'high',
'最低': 'low',
'收盘': 'close',
'成交量': 'volume',
'换手率': 'turnover'
})
# 设置日期索引
df['date'] = pd.to_datetime(df['date'])
df.set_index('date', inplace=True)
return df
## 使用
df = get_stock_data('000001', start_date='20230101', end_date='20241231')
print(df.head())
print(f"数据行数: {len(df)}")
print(f"时间范围: {df.index.min()} 至 {df.index.max()}")2.3 使用 yfinance 获取美股数据
import yfinance as yf
def get_us_stock_data(ticker: str, start_date: str = None, end_date: str = None) -> pd.DataFrame:
"""
获取美股数据
Args:
ticker: 股票代码,如 'AAPL'
start_date: 'YYYY-MM-DD'
end_date: 'YYYY-MM-DD'
"""
stock = yf.Ticker(ticker)
df = stock.history(
start=start_date,
end=end_date,
interval='1d', # 日线数据
auto_adjust=True # 自动调整
)
return df
## 使用
df = get_us_stock_data('AAPL', start_date='2023-01-01', end_date='2024-12-31')
print(df.head())2.4 数据质量检查
def check_data_quality(df: pd.DataFrame):
"""检查数据质量"""
issues = []
# 1. 检查缺失值
missing = df.isnull().sum()
if missing.any():
issues.append(f"存在缺失值: {missing[missing > 0].to_dict()}")
# 2. 检查价格异常(负值或零值)
for col in ['open', 'high', 'low', 'close']:
if (df[col] <= 0).any():
issues.append(f"{col} 列存在非正值")
# 3. 检查成交量异常
if (df['volume'] < 0).any():
issues.append("成交量列存在负值")
# 4. 检查价格逻辑(最高价 >= 最低价)
invalid = (df['high'] < df['low']).sum()
if invalid > 0:
issues.append(f"存在 {invalid} 条数据最高价低于最低价")
# 5. 检查连续性
date_diff = df.index.to_series().diff()
non_trading_days = date_diff[date_diff > pd.Timedelta(days=7)].count()
if non_trading_days > 0:
issues.append(f"存在 {non_trading_days} 处长时间间隔")
# 输出报告
if issues:
print("⚠️ 数据质量问题:")
for issue in issues:
print(f" - {issue}")
else:
print("✅ 数据质量检查通过")
return len(issues) == 0
## 使用
check_data_quality(df)2.5 数据清洗与预处理
def clean_data(df: pd.DataFrame) -> pd.DataFrame:
"""数据清洗"""
df = df.copy()
# 1. 填充缺失值(前向填充)
df.fillna(method='ffill', inplace=True)
# 2. 删除仍存在的缺失行
df.dropna(inplace=True)
# 3. 处理异常值(使用滚动中位数替换)
for col in ['open', 'high', 'low', 'close']:
median = df[col].rolling(window=5, center=True).median()
# 替换超出3倍标准差的值
std = df[col].rolling(window=5).std()
outliers = (df[col] - median).abs() > 3 * std
df.loc[outliers, col] = median
# 4. 计算收益率
df['return'] = df['close'].pct_change()
df['log_return'] = np.log(df['close'] / df['close'].shift(1))
# 5. 计算成交量移动平均
df['volume_ma5'] = df['volume'].rolling(5).mean()
df['volume_ma20'] = df['volume'].rolling(20).mean()
return df
## 使用
df_clean = clean_data(df)
print(df_clean.head())四、技术指标理论与策略开发
学习目标:理解技术指标的数学原理、适用场景和局限性
4.1 技术指标分类与选择
4.1.1 技术指标的四大类别
1. 趋势类指标(Trend Indicators)
- 原理:通过平滑价格波动,识别趋势方向
- 代表:MA、EMA、MACD
- 适用场景:趋势明显的市场(单边行情)
- 失效场景:震荡市(横盘整理)
2. 震荡类指标(Oscillators)
- 原理:衡量价格偏离正常范围的程度
- 代表:RSI、KDJ、随机指标
- 适用场景:震荡市、超买超卖判断
- 失效场景:强趋势市场(连续超买/超卖)
3. 波动率指标(Volatility Indicators)
- 原理:衡量价格波动的剧烈程度
- 代表:布林带(BOLL)、ATR
- 适用场景:风险控制、突破判断
- 用途:设置止损止盈位置
4. 成交量指标(Volume Indicators)
- 原理:通过成交量确认价格趋势
- 代表:OBV、量价关系
- 核心思想:量先于价(成交量是价格的先行指标)
4.1.2 指标选择的黄金法则
| 法则 | 说明 | 原因 |
|---|---|---|
| 趋势+震荡组合 | 同时使用不同类型指标 | 互相确认,降低假信号 |
| 避免同类指标 | 不要同时用MA和EMA | 冗余信息,无新增价值 |
| 简单优于复杂 | 优先选择简单指标 | 可解释性强,参数少 |
| 验证再使用 | 回测验证有效性 | 避免"数据拟合陷阱" |
4.2 趋势类指标深入解析
4.2.1 移动平均线(MA)
数学定义:
核心思想:通过平均价格消除短期波动,显示趋势方向。
常用周期及含义:
| 周期 | 名称 | 用途 | 交易者类型 |
|---|---|---|---|
| MA5 | 5日线 | 超短线趋势 | 日内交易者 |
| MA10 | 10日线 | 短期趋势 | 短线交易者 |
| MA20 | 月线 | 中短期趋势 | 波段交易者 |
| MA60 | 季线 | 中期趋势 | 趋势交易者 |
| MA120 | 半年线 | 长期趋势 | 价值投资者 |
| MA250 | 年线 | 牛熊分界 | 长期投资者 |
交易信号:
金叉(Golden Cross):
├─ 定义:短期MA上穿长期MA
├─ 含义:多头趋势形成
└─ 操作:买入信号
死叉(Death Cross):
├─ 定义:短期MA下穿长期MA
├─ 含义:空头趋势形成
└─ 操作:卖出信号
黏合(MA Convergence):
├─ 定义:多条MA聚集
├─ 含义:变盘在即(蓄势待发)
└─ 操作:观望等待突破优缺点:
✅ 优点:
- 简单直观,易于理解
- 平滑噪音,显示趋势
- 可作为动态支撑/阻力位
❌ 缺点:
- 滞后性(Lagging Indicator):趋势已经形成才发出信号
- 震荡市频繁假突破
- 参数敏感性:不同周期结果差异大
4.2.2 指数移动平均线(EMA)
数学定义:
其中平滑因子:
与SMA的区别:
SMA(简单移动平均):
├─ 所有数据权重相同
├─ 计算:(P1 + P2 + ... + Pn) / n
└─ 特点:反应慢,噪音少
EMA(指数移动平均):
├─ 近期数据权重大
├─ 计算:递归加权
└─ 特点:反应快,更贴近实时价格权重衰减示例(EMA20):
| 天数 | 权重 | 说明 |
|---|---|---|
| 今天 | 9.52% | 最近数据权重最大 |
| 1天前 | 8.61% | 权重呈指数衰减 |
| 5天前 | 6.09% | ... |
| 10天前 | 3.71% | ... |
| 20天前 | 1.29% | 远期数据权重小 |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
## 对比SMA和EMA
df['SMA20'] = df['close'].rolling(20).mean()
df['EMA20'] = df['close'].ewm(span=20, adjust=False).mean()
## 可视化
plt.figure(figsize=(14, 7))
plt.plot(df.index, df['close'], label='Price', alpha=0.7)
plt.plot(df.index, df['SMA20'], label='SMA20', linewidth=2)
plt.plot(df.index, df['EMA20'], label='EMA20', linewidth=2)
plt.legend()
plt.title('SMA vs EMA: EMA更贴近价格,响应更快')
plt.show()4.2.3 MACD(指数平滑异同移动平均线)
核心思想:比较两条不同周期的EMA,衡量动量变化。
计算公式:
三条线的含义:
| 线 | 计算 | 含义 |
|---|---|---|
| DIF线(快线) | EMA12 - EMA26 | 短期动量 |
| DEA线(慢线) | DIF的9日EMA | 动量的趋势 |
| MACD柱 | (DIF - DEA) × 2 | 动量加速度 |
交易信号:
1. DIF与DEA的交叉:
├─ DIF上穿DEA:金叉,买入
└─ DIF下穿DEA:死叉,卖出
2. MACD柱的变化:
├─ 柱体由负转正:多头力量增强
├─ 柱体由正转负:空头力量增强
├─ 柱体放大:趋势加速
└─ 柱体缩小:趋势减弱
3. 零轴的意义:
├─ DIF > 0:短期均价 > 长期均价,多头市场
└─ DIF < 0:短期均价 < 长期均价,空头市场
4. 背离(Divergence):
├─ 顶背离:价格创新高,MACD未创新高 → 见顶信号
└─ 底背离:价格创新低,MACD未创新低 → 见底信号代码实现与可视化:
import talib
## 计算MACD
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(
df['close'].values,
fastperiod=12,
slowperiod=26,
signalperiod=9
)
## 可视化
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), sharex=True)
## 上图:价格
ax1.plot(df.index, df['close'], label='Close Price')
ax1.set_ylabel('Price')
ax1.legend()
ax1.set_title('MACD指标示例')
ax1.grid(True)
## 下图:MACD
ax2.plot(df.index, df['MACD'], label='DIF (MACD)', color='blue')
ax2.plot(df.index, df['MACD_signal'], label='DEA (Signal)', color='red')
ax2.bar(df.index, df['MACD_hist'], label='MACD Histogram', alpha=0.3, color='gray')
ax2.axhline(0, color='black', linewidth=0.5, linestyle='--')
ax2.set_ylabel('MACD')
ax2.legend()
ax2.grid(True)
plt.tight_layout()
plt.show()MACD的局限性:
- 滞后性:基于EMA计算,信号慢于价格
- 震荡市失效:频繁金叉死叉,假信号多
- 参数敏感:12/26/9是默认值,不一定适合所有品种
4.3 震荡类指标深入解析
4.3.1 RSI(相对强弱指标)
核心思想:衡量一定时期内上涨力量与下跌力量的对比。
计算公式:
其中:
取值范围: 0 ~ 100
判断标准:
| RSI值 | 市场状态 | 操作建议 |
|---|---|---|
| > 70 | 超买(Overbought) | 警惕回调,可考虑减仓 |
| 50~70 | 强势 | 持股观望 |
| 30~50 | 弱势 | 观望 |
| < 30 | 超卖(Oversold) | 可能反弹,可考虑买入 |
交易信号:
1. 超买超卖:
├─ RSI > 80:严重超买,警惕顶部
├─ RSI < 20:严重超卖,可能见底
└─ 注意:强趋势中RSI可长期超买/超卖
2. 中线穿越:
├─ RSI上穿50:多头市场
└─ RSI下穿50:空头市场
3. 背离:
├─ 顶背离:价格新高,RSI未新高 → 趋势弱化
└─ 底背离:价格新低,RSI未新低 → 即将反转
4. 形态分析:
├─ 头肩顶/底:与价格形态对应
└─ 支撑阻力:RSI也有支撑阻力位代码实现:
## 计算RSI
df['RSI14'] = talib.RSI(df['close'].values, timeperiod=14)
## 可视化
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), sharex=True)
## 价格
ax1.plot(df.index, df['close'])
ax1.set_ylabel('Price')
ax1.set_title('RSI指标示例')
ax1.grid(True)
## RSI
ax2.plot(df.index, df['RSI14'], color='purple', linewidth=2)
ax2.axhline(70, color='r', linestyle='--', label='超买线')
ax2.axhline(30, color='g', linestyle='--', label='超卖线')
ax2.axhline(50, color='gray', linestyle=':', label='中线')
ax2.fill_between(df.index, 30, 70, alpha=0.1, color='blue')
ax2.set_ylabel('RSI')
ax2.set_ylim(0, 100)
ax2.legend()
ax2.grid(True)
plt.tight_layout()
plt.show()RSI的改进应用:
def advanced_rsi_strategy(df, rsi_period=14):
"""改进的RSI策略:结合趋势过滤"""
df = df.copy()
# 计算RSI和MA
df['RSI'] = talib.RSI(df['close'].values, timeperiod=rsi_period)
df['MA50'] = df['close'].rolling(50).mean()
# 信号生成
df['signal'] = 0
# 只在上升趋势中买入超卖
buy_condition = (
(df['RSI'] < 30) & # RSI超卖
(df['close'] > df['MA50']) # 价格在MA50之上(确认趋势)
)
df.loc[buy_condition, 'signal'] = 1
# 只在下降趋势中卖出超买
sell_condition = (
(df['RSI'] > 70) & # RSI超买
(df['close'] < df['MA50']) # 价格在MA50之下
)
df.loc[sell_condition, 'signal'] = -1
return df4.3.2 KDJ 随机指标
核心思想:比较收盘价在一定周期内最高最低价区间的位置。
计算公式:
- :今日收盘价
- :n日内最低价
- :n日内最高价
- RSV:未成熟随机值(Raw Stochastic Value)
三条线的含义:
| 线 | 含义 | 特点 |
|---|---|---|
| K线 | RSV的平滑(快线) | 反应灵敏 |
| D线 | K的平滑(慢线) | 反应平缓 |
| J线 | K和D的偏离度 | 最敏感,可超出0-100 |
判断标准:
超买超卖:
├─ K、D > 80:超买区
├─ K、D < 20:超卖区
└─ J > 100或< 0:极度超买/超卖
金叉死叉:
├─ K上穿D:金叉,买入
└─ K下穿D:死叉,卖出
钝化现象:
├─ 强势股:KDJ长期高位钝化(>80)
└─ 弱势股:KDJ长期低位钝化(<20)4.4 波动率指标深入解析
4.4.1 布林带(Bollinger Bands)
核心思想:价格在均值±标准差的范围内波动。
计算公式:
- :n日移动平均(通常n=20)
- :n日标准差
- :标准差倍数(通常k=2)
统计意义:
根据正态分布:
- 68%的价格在 ± 1倍标准差内
- 95%的价格在 ± 2倍标准差内
- 99.7%的价格在 ± 3倍标准差内
交易信号:
1. 触及上轨:
├─ 上涨趋势:继续持有
└─ 震荡/顶部:考虑减仓
2. 触及下轨:
├─ 下跌趋势:观望
└─ 震荡/底部:考虑买入
3. 布林带宽度(Bandwidth):
├─ 收窄:波动率降低,变盘在即
└─ 扩张:波动率增加,趋势确认
4. 保利加通道突破:
├─ 突破上轨 + 放量:强势突破
└─ 跌破下轨 + 放量:弱势破位
5. 布林中轨:
├─ 价格在中轨之上:多头市场
└─ 价格在中轨之下:空头市场代码实现:
## 计算布林带
df['BOLL_upper'], df['BOLL_middle'], df['BOLL_lower'] = talib.BBANDS(
df['close'].values,
timeperiod=20,
nbdevup=2,
nbdevdn=2
)
## 计算带宽(Bandwidth)
df['BOLL_width'] = (df['BOLL_upper'] - df['BOLL_lower']) / df['BOLL_middle']
## 可视化
plt.figure(figsize=(14, 7))
plt.plot(df.index, df['close'], label='Close', color='black', linewidth=2)
plt.plot(df.index, df['BOLL_upper'], label='Upper Band', color='red', linestyle='--')
plt.plot(df.index, df['BOLL_middle'], label='Middle Band', color='blue')
plt.plot(df.index, df['BOLL_lower'], label='Lower Band', color='green', linestyle='--')
plt.fill_between(df.index, df['BOLL_lower'], df['BOLL_upper'], alpha=0.1, color='gray')
plt.legend()
plt.title('布林带(Bollinger Bands)')
plt.grid(True)
plt.show()4.4.2 ATR(平均真实波幅)
核心思想:衡量价格波动的剧烈程度(波动率)。
计算公式:
- :真实波幅(True Range)
- :今日最高价
- :今日最低价
- :昨日收盘价
应用场景:
设置止损位:
止损距离 = ATR × 倍数(通常2-3倍) 止损价 = 入场价 - 2 × ATR(做多时)判断突破有效性:
有效突破 = 突破幅度 > ATR × 1.5仓位管理:
波动率大(ATR高)→ 减小仓位 波动率小(ATR低)→ 增加仓位
## 计算ATR
df['ATR14'] = talib.ATR(df['high'].values, df['low'].values, df['close'].values, timeperiod=14)
## 基于ATR的止损策略
def atr_stop_loss(entry_price, atr, position='long', multiplier=2):
"""
基于ATR的止损价计算
Args:
entry_price: 入场价格
atr: 当前ATR值
position: 'long' 或 'short'
multiplier: ATR倍数
"""
if position == 'long':
stop_loss = entry_price - multiplier * atr
else:
stop_loss = entry_price + multiplier * atr
return stop_loss
## 使用
entry = 100.0
current_atr = 2.5
stop = atr_stop_loss(entry, current_atr, position='long', multiplier=2)
print(f"入场价: {entry}, ATR: {current_atr}, 止损价: {stop:.2f}")4.5 常用技术指标速查
| 指标 | 类别 | 用途 | 周期 | Python 实现 |
|---|---|---|---|---|
| MA | 趋势 | 判断趋势方向 | 5/10/20/60 | df['close'].rolling(n).mean() |
| EMA | 趋势 | 快速响应趋势 | 12/26 | df['close'].ewm(span=n).mean() |
| MACD | 动量 | 趋势转换信号 | 12/26/9 | talib.MACD() |
| RSI | 震荡 | 超买超卖判断 | 6/12/24 | talib.RSI() |
| KDJ | 震荡 | 超买超卖+金叉死叉 | 9/3/3 | talib.STOCH() |
| BOLL | 波动 | 价格通道 | 20 | talib.BBANDS() |
| ATR | 波动 | 波动率测量 | 14 | talib.ATR() |
4.6 技术指标批量计算
3.2 使用 TA-Lib 计算指标
pip install TA-Lib指标计算示例:
import talib
import numpy as np
import pandas as pd
def calculate_indicators(df: pd.DataFrame) -> pd.DataFrame:
"""计算常用技术指标"""
df = df.copy()
close = df['close'].values
high = df['high'].values
low = df['low'].values
volume = df['volume'].values
# 移动平均线
df['MA5'] = talib.MA(close, timeperiod=5)
df['MA10'] = talib.MA(close, timeperiod=10)
df['MA20'] = talib.MA(close, timeperiod=20)
df['MA60'] = talib.MA(close, timeperiod=60)
# 指数移动平均
df['EMA12'] = talib.EMA(close, timeperiod=12)
df['EMA26'] = talib.EMA(close, timeperiod=26)
# MACD
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(close)
# RSI
df['RSI6'] = talib.RSI(close, timeperiod=6)
df['RSI12'] = talib.RSI(close, timeperiod=12)
df['RSI24'] = talib.RSI(close, timeperiod=24)
# 布林带
df['BOLL_upper'], df['BOLL_middle'], df['BOLL_lower'] = talib.BBANDS(close)
# ATR(真实波幅)
df['ATR'] = talib.ATR(high, low, close, timeperiod=14)
# KDJ
slowk, slowd = talib.STOCH(high, low, close)
df['K'] = slowk
df['D'] = slowd
df['J'] = 3 * slowk - 2 * slowd
return df
## 使用
df_indicators = calculate_indicators(df_clean)
print(df_indicators[['MA5', 'MA20', 'MACD', 'RSI12']].tail())3.3 使用 pandas-ta 计算指标
pip install pandas-taimport pandas_ta as ta
def calculate_indicators_pandasta(df: pd.DataFrame) -> pd.DataFrame:
"""使用 pandas-ta 计算指标(更简单)"""
df = df.copy()
# 移动平均
df.ta.sma(length=20, append=True) # SMA_20
df.ta.ema(length=12, append=True) # EMA_12
# MACD
macd = df.ta.macd(fast=12, slow=26, signal=9)
df = pd.concat([df, macd], axis=1)
# RSI
df.ta.rsi(length=14, append=True) # RSI_14
# 布林带
bbands = df.ta.bbands(length=20, std=2)
df = pd.concat([df, bbands], axis=1)
# ATR
df.ta.atr(length=14, append=True) # ATR_14
return df
## 使用
df_ta = calculate_indicators_pandasta(df_clean)3.4 双均线策略
class DualMAStrategy:
"""双均线策略"""
def __init__(self, fast_period: int = 5, slow_period: int = 20):
self.fast_period = fast_period
self.slow_period = slow_period
def generate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
"""
生成交易信号
Returns:
DataFrame 添加以下列:
- signal: 买入=1, 卖出=-1, 无信号=0
- position: 持仓状态
"""
df = df.copy()
# 计算均线
df['MA_fast'] = df['close'].rolling(self.fast_period).mean()
df['MA_slow'] = df['close'].rolling(self.slow_period).mean()
# 生成信号
# 金叉:快线上穿慢线
df['signal'] = 0
df.loc[(df['MA_fast'] > df['MA_slow']) &
(df['MA_fast'].shift(1) <= df['MA_slow'].shift(1)), 'signal'] = 1
# 死叉:快线下穿慢线
df.loc[(df['MA_fast'] < df['MA_slow']) &
(df['MA_fast'].shift(1) >= df['MA_slow'].shift(1)), 'signal'] = -1
# 计算持仓
df['position'] = df['signal'].replace(0, method='ffill').fillna(0)
return df
def backtest(self, df: pd.DataFrame, initial_capital: float = 100000) -> dict:
"""简单回测"""
df_signals = self.generate_signals(df)
# 计算收益
df_signals['strategy_return'] = df_signals['position'].shift(1) * df_signals['return']
df_signals['cumulative_return'] = (1 + df_signals['strategy_return']).cumprod()
# 计算策略最终价值
final_value = initial_capital * df_signals['cumulative_return'].iloc[-1]
buy_hold_return = (df['close'].iloc[-1] / df['close'].iloc[0] - 1) * initial_capital
return {
'final_value': final_value,
'strategy_return': final_value - initial_capital,
'buy_hold_return': buy_hold_return,
'excess_return': final_value - initial_capital - buy_hold_return,
'signals_df': df_signals
}
## 使用
strategy = DualMAStrategy(fast_period=5, slow_period=20)
result = strategy.backtest(df_clean)
print(f"初始资金: ¥100,000")
print(f"策略最终: ¥{result['final_value']:,.2f}")
print(f"策略收益: ¥{result['strategy_return']:,.2f}")
print(f"买入持有: ¥{result['buy_hold_return']:,.2f}")
print(f"超额收益: ¥{result['excess_return']:,.2f}")3.5 MACD + RSI 组合策略
class MACDRSIStrategy:
"""MACD + RSI 组合策略"""
def __init__(self, macd_fast: int = 12, macd_slow: int = 26,
macd_signal: int = 9, rsi_period: int = 14,
rsi_oversold: int = 30, rsi_overbought: int = 70):
self.macd_fast = macd_fast
self.macd_slow = macd_slow
self.macd_signal = macd_signal
self.rsi_period = rsi_period
self.rsi_oversold = rsi_oversold
self.rsi_overbought = rsi_overbought
def generate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
"""生成交易信号"""
df = df.copy()
# 计算指标
close = df['close'].values
df['MACD'], df['MACD_signal'], df['MACD_hist'] = talib.MACD(
close,
fastperiod=self.macd_fast,
slowperiod=self.macd_slow,
signalperiod=self.macd_signal
)
df['RSI'] = talib.RSI(close, timeperiod=self.rsi_period)
# 生成信号
# 买入条件:MACD金叉且RSI未超买
buy_signal = (
(df['MACD'] > df['MACD_signal']) &
(df['MACD'].shift(1) <= df['MACD_signal'].shift(1)) &
(df['RSI'] < self.rsi_overbought)
)
# 卖出条件:MACD死叉或RSI超买
sell_signal = (
((df['MACD'] < df['MACD_signal']) &
(df['MACD'].shift(1) >= df['MACD_signal'].shift(1))) |
(df['RSI'] > self.rsi_overbought)
)
df['signal'] = 0
df.loc[buy_signal, 'signal'] = 1
df.loc[sell_signal, 'signal'] = -1
# 计算持仓
df['position'] = df['signal'].replace(0, method='ffill').fillna(0)
return df四、回测框架 Backtrader
4.1 Backtrader 简介
核心组件:
| 组件 | 作用 |
|---|---|
| Cerebro | 核心引擎,管理整个回测过程 |
| DataFeed | 数据源,负责提供价格数据 |
| Strategy | 交易策略,定义买卖逻辑 |
| Indicator | 技术指标,辅助决策 |
| Analyzer | 分析器,评估策略表现 |
| Broker | 模拟券商,处理订单和成交 |
4.2 Backtrader 快速入门
import backtrader as bt
import matplotlib.pyplot as plt
import akshare as ak
## 1. 创建数据
def get_bt_data(stock_code: str, start_date: str) -> bt.feeds.PandasData:
"""获取 Backtrader 可用的数据"""
df = ak.stock_zh_a_hist(
symbol=stock_code,
period="daily",
start_date=start_date,
adjust="qfq"
)
df = df.rename(columns={
'日期': 'datetime',
'开盘': 'open',
'最高': 'high',
'最低': 'low',
'收盘': 'close',
'成交量': 'volume'
})
df['datetime'] = pd.to_datetime(df['datetime'])
df.set_index('datetime', inplace=True)
# 创建数据源
data = bt.feeds.PandasData(dataname=df)
return data
## 2. 创建策略
class SMACrossStrategy(bt.Strategy):
"""双均线交叉策略"""
params = (
('fast_period', 5),
('slow_period', 20),
)
def __init__(self):
# 计算指标
self.fast_ma = bt.indicators.SMA(self.data.close, period=self.params.fast_period)
self.slow_ma = bt.indicators.SMA(self.data.close, period=self.params.slow_period)
# 交叉信号
self.crossover = bt.indicators.CrossOver(self.fast_ma, self.slow_ma)
def next(self):
"""每个bar调用一次"""
# 如果没有持仓且金叉,买入
if not self.position:
if self.crossover > 0: # 金叉
size = self.broker.getcash() / self.data.close[0] * 0.95 # 95%仓位
self.buy(size=size)
print(f"{self.data.datetime.date(0)}: 买入 {size:.2f} 股,价格 {self.data.close[0]:.2f}")
# 如果有持仓且死叉,卖出
elif self.position:
if self.crossover < 0: # 死叉
self.close()
print(f"{self.data.datetime.date(0)}: 卖出,价格 {self.data.close[0]:.2f}")
## 3. 运行回测
def run_backtest():
"""运行回测"""
# 创建引擎
cerebro = bt.Cerebro()
# 添加策略
cerebro.addstrategy(SMACrossStrategy, fast_period=5, slow_period=20)
# 添加数据
data = get_bt_data('000001', '20230101')
cerebro.adddata(data)
# 设置初始资金
cerebro.broker.setcash(100000.0)
# 设置手续费(万三)
cerebro.broker.setcommission(commission=0.0003)
# 添加分析器
cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')
cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')
# 运行
print('初始资金: ¥%.2f' % cerebro.broker.getvalue())
results = cerebro.run()
# 输出结果
strat = results[0]
print('最终资金: ¥%.2f' % cerebro.broker.getvalue())
print('总收益率: %.2f%%' % ((cerebro.broker.getvalue() / 100000 - 1) * 100))
print('夏普比率: %.2f' % strat.analyzers.sharpe.get_analysis()['sharperatio'])
print('最大回撤: %.2f%%' % strat.analyzers.drawdown.get_analysis()['max']['drawdown'])
# 绘制
cerebro.plot(style='candlestick')
## 运行
run_backtest()4.3 自定义指标
class CustomIndicator(bt.Indicator):
"""自定义指标 - 例如:价格动量"""
lines = ('momentum',)
params = (('period', 10),)
plotinfo = dict(
subplot=False,
plotabove=True
)
def __init__(self):
# 计算动量:当前价格 - N天前价格
self.lines.momentum = self.data.close - self.data.close(-self.params.period)
## 在策略中使用
class StrategyWithCustom(bt.Strategy):
def __init__(self):
self.momentum = CustomIndicator(self.data, period=10)
# 当动量 > 0 且上升时买入
self.buy_signal = bt.indicators.CrossOver(self.momentum, 0)4.4 回测绩效分析
def detailed_analysis(cerebro, results):
"""详细的绩效分析"""
strat = results[0]
# 1. 夏普比率
sharpe = strat.analyzers.sharpe.get_analysis()
print(f"\n=== 夏普比率 ===")
print(f"夏普比率: {sharpe['sharperatio']:.4f}")
print(f"年化夏普: {sharpe.get('sharperatio', 0) * (252**0.5):.4f}")
# 2. 回撤分析
drawdown = strat.analyzers.drawdown.get_analysis()
print(f"\n=== 回撤分析 ===")
print(f"最大回撤: {drawdown['max']['drawdown']:.2f}%")
print(f"最大回撤持续天数: {drawdown['max']['len']} 天")
# 3. 交易分析
trades = strat.analyzers.trades.get_analysis()
print(f"\n=== 交易分析 ===")
print(f"总交易次数: {trades['total']['total']}")
print(f"盈利交易: {trades['won']['total']}")
print(f"亏损交易: {trades['lost']['total']}")
print(f"胜率: {trades['won']['total'] / trades['total']['total'] * 100:.2f}%")
print(f"平均盈利: ¥{trades['won']['pnl']['average']:.2f}")
print(f"平均亏损: ¥{trades['lost']['pnl']['average']:.2f}")
print(f"盈亏比: {abs(trades['won']['pnl']['average'] / trades['lost']['pnl']['average']):.2f}")
# 4. 自定义指标
final_value = cerebro.broker.getvalue()
total_return = (final_value / 100000 - 1) * 100
print(f"\n=== 总体表现 ===")
print(f"初始资金: ¥100,000")
print(f"最终资金: ¥{final_value:,.2f}")
print(f"总收益率: {total_return:.2f}%")六、风险管理理论与实践
学习目标:深入理解金融风险的本质、度量方法和管理策略
6.1 风险的本质与分类
6.1.1 什么是风险?
定义:投资收益的不确定性。
风险 ≠ 亏损:
- 风险是波动性(Volatility),包括上涨和下跌的不确定性
- 现代金融理论:风险 = 标准差(收益率的离散程度)
风险的两面性:
收益
↑
高风险 ──────┼──────── 高收益
│
低风险 ──────┼──────── 低收益
│
风险 →6.1.2 风险的分类
| 风险类型 | 定义 | 能否分散 | 应对方法 |
|---|---|---|---|
| 系统性风险 | 整个市场的风险(经济衰退、战争) | ❌ 不能 | 对冲、止损 |
| 非系统性风险 | 个股/行业特有风险(公司破产) | ✅ 能 | 分散投资 |
| 流动性风险 | 无法快速变现 | ❌ 不能 | 选择大盘股 |
| 信用风险 | 对手方违约 | ⚠️ 部分能 | 选择优质标的 |
系统性风险(Beta)vs 非系统性风险(Alpha):
- 系统性风险:无法通过分散化消除(如2008年金融危机)
- 非系统性风险:可通过持有多只股票分散
分散化的数学原理:
当股票数量 增加且相关性 时,组合波动率 下降。
import numpy as np
## 模拟分散化效果
n_stocks = np.arange(1, 51)
portfolio_risk = []
for n in n_stocks:
# 假设单股风险20%,股票间相关性0.3
individual_risk = 0.20
correlation = 0.3
# 组合风险公式
risk = individual_risk * np.sqrt((1 + (n-1)*correlation) / n)
portfolio_risk.append(risk)
## 可视化
plt.figure(figsize=(10, 6))
plt.plot(n_stocks, portfolio_risk, linewidth=2)
plt.axhline(0.20 * np.sqrt(0.3), color='r', linestyle='--', label='系统性风险下限')
plt.xlabel('持股数量')
plt.ylabel('组合波动率')
plt.title('分散化效应:持股数量越多,非系统性风险越低')
plt.legend()
plt.grid(True)
plt.show()6.2 风险度量指标详解
6.2.1 最大回撤(Maximum Drawdown, MDD)
定义:从历史最高点到最低点的最大跌幅。
计算步骤:
- 计算每日累计收益
- 计算每日历史最高峰值
- 计算每日回撤 = (峰值 - 当前值) / 峰值
- 取最大回撤
def calculate_max_drawdown(returns: pd.Series) -> dict:
"""
计算最大回撤及相关指标
Returns:
dict: 包含最大回撤、回撤开始/结束日期、持续天数
"""
# 计算累计收益
cumulative = (1 + returns).cumprod()
# 计算历史最高点
running_max = cumulative.cummax()
# 计算回撤序列
drawdown = (cumulative - running_max) / running_max
# 最大回撤
max_dd = drawdown.min()
# 最大回撤结束时间(谷底)
end_date = drawdown.idxmin()
# 最大回撤开始时间(峰值)
start_date = cumulative[:end_date].idxmax()
# 持续天数
duration = (end_date - start_date).days
return {
'max_drawdown': max_dd,
'start_date': start_date,
'end_date': end_date,
'duration_days': duration,
'drawdown_series': drawdown
}
## 使用
returns = df['close'].pct_change().dropna()
dd_info = calculate_max_drawdown(returns)
print(f"最大回撤: {dd_info['max_drawdown']:.2%}")
print(f"开始日期: {dd_info['start_date']}")
print(f"结束日期: {dd_info['end_date']}")
print(f"持续天数: {dd_info['duration_days']} 天")
## 可视化回撤曲线
plt.figure(figsize=(14, 7))
dd_info['drawdown_series'].plot(kind='area', color='red', alpha=0.3)
plt.title('回撤曲线')
plt.ylabel('回撤比例')
plt.axhline(dd_info['max_drawdown'], color='darkred', linestyle='--',
label=f'最大回撤: {dd_info["max_drawdown"]:.2%}')
plt.legend()
plt.grid(True)
plt.show()最大回撤的实际意义:
最大回撤 -50% 的含义:
├─ 需要 +100% 才能回本(1 / (1 - 0.5) - 1 = 1)
├─ 心理压力极大,容易割肉
└─ 对杠杆交易尤其致命
可接受的最大回撤:
├─ 保守型投资者:< 10%
├─ 稳健型投资者:10% ~ 20%
├─ 激进型投资者:20% ~ 30%
└─ 超过 30%:需审视策略6.2.2 夏普比率(Sharpe Ratio)
定义:每承担一单位风险,获得多少超额收益。
- :投资组合收益率
- :无风险利率(如3年期国债利率 ≈ 3%)
- :收益率标准差(波动率)
判断标准:
| 夏普比率 | 评价 | 说明 |
|---|---|---|
| < 0 | 差 | 收益低于无风险利率,不如买国债 |
| 0 ~ 1 | 一般 | 风险收益比不高 |
| 1 ~ 2 | 良好 | 专业水平 |
| 2 ~ 3 | 优秀 | 顶级水平 |
| > 3 | 卓越 | 极少见,需警惕数据拟合 |
def calculate_sharpe_ratio(returns: pd.Series, risk_free_rate: float = 0.03) -> float:
"""
计算夏普比率
Args:
returns: 日收益率序列
risk_free_rate: 年化无风险利率
"""
# 年化收益率
annual_return = returns.mean() * 252
# 年化波动率
annual_vol = returns.std() * np.sqrt(252)
# 夏普比率
sharpe = (annual_return - risk_free_rate) / annual_vol
return sharpe
## 使用
sharpe = calculate_sharpe_ratio(returns)
print(f"夏普比率: {sharpe:.2f}")
if sharpe < 0:
print("⚠️ 策略收益低于无风险利率,建议优化")
elif sharpe < 1:
print("📊 策略表现一般")
elif sharpe < 2:
print("✅ 策略表现良好")
else:
print("🏆 策略表现优秀")夏普比率的局限性:
- 假设收益服从正态分布(实际是厚尾分布)
- 无法区分上行和下行波动(索提诺比率改进)
- 对异常值敏感
改进版:索提诺比率(Sortino Ratio)
只惩罚下行波动(负收益的标准差):
def calculate_sortino_ratio(returns: pd.Series, risk_free_rate: float = 0.03) -> float:
"""计算索提诺比率(只考虑下行风险)"""
# 年化收益率
annual_return = returns.mean() * 252
# 下行波动率(只计算负收益)
downside_returns = returns[returns < 0]
downside_vol = downside_returns.std() * np.sqrt(252)
# 索提诺比率
sortino = (annual_return - risk_free_rate) / downside_vol
return sortino
sortino = calculate_sortino_ratio(returns)
print(f"索提诺比率: {sortino:.2f}")6.2.3 VaR(风险价值)
定义:在给定置信水平下,预期的最大损失。
示例:
- 95% VaR = ¥50,000 的含义:
- 有95%的概率,日亏损 < ¥50,000
- 有5%的概率,日亏损 > ¥50,000
计算方法:
方法一:历史模拟法
def calculate_var_historical(returns: pd.Series, confidence_level: float = 0.95) -> float:
"""
历史模拟法计算VaR
Args:
returns: 收益率序列
confidence_level: 置信水平(如0.95表示95%)
"""
# 计算分位数
var = returns.quantile(1 - confidence_level)
return var
## 使用
var_95 = calculate_var_historical(returns, 0.95)
var_99 = calculate_var_historical(returns, 0.99)
print(f"95% VaR: {var_95:.2%}(日亏损不超过此值的概率为95%)")
print(f"99% VaR: {var_99:.2%}(日亏损不超过此值的概率为99%)")
## 换算成金额
capital = 100000
print(f"\n如果本金 ¥{capital:,}:")
print(f"95% VaR: 日亏损 < ¥{abs(var_95 * capital):,.2f}")
print(f"99% VaR: 日亏损 < ¥{abs(var_99 * capital):,.2f}")方法二:参数法(假设正态分布)
def calculate_var_parametric(returns: pd.Series, confidence_level: float = 0.95) -> float:
"""参数法计算VaR(假设正态分布)"""
from scipy import stats
mu = returns.mean()
sigma = returns.std()
# 标准正态分布的分位数
z_score = stats.norm.ppf(1 - confidence_level)
# VaR
var = mu + z_score * sigma
return var方法三:蒙特卡洛模拟
def calculate_var_monte_carlo(returns: pd.Series, confidence_level: float = 0.95,
n_simulations: int = 10000) -> float:
"""蒙特卡洛模拟计算VaR"""
mu = returns.mean()
sigma = returns.std()
# 模拟未来收益率
simulated_returns = np.random.normal(mu, sigma, n_simulations)
# 计算VaR
var = np.percentile(simulated_returns, (1 - confidence_level) * 100)
return var6.2.4 CVaR(条件风险价值)
定义:超过VaR时的平均损失(尾部风险)。
def calculate_cvar(returns: pd.Series, confidence_level: float = 0.95) -> float:
"""计算CVaR(条件VaR)"""
var = calculate_var_historical(returns, confidence_level)
# 计算超过VaR的平均损失
cvar = returns[returns < var].mean()
return cvar
cvar_95 = calculate_cvar(returns, 0.95)
print(f"95% CVaR: {cvar_95:.2%}(在最坏的5%情况下,平均亏损)")6.3 仓位管理理论
6.3.1 固定比例法
原理:每次交易投入固定比例的资金。
优点:
- 简单易行
- 风险可控
缺点:
- 未考虑胜率和盈亏比
- 可能过于保守或激进
def fixed_ratio_position(capital: float, allocation_pct: float = 0.2) -> float:
"""固定比例仓位管理"""
return capital * allocation_pct6.3.2 凯利公式(Kelly Criterion)
理论基础:信息论创始人 John Kelly 于1956年提出。
目标:最大化资金增长的长期几何平均收益。
公式:
- :最优仓位比例
- :获胜概率(胜率)
- :失败概率
- :盈亏比(平均盈利 / 平均亏损)
示例计算:
假设策略:
├─ 胜率 p = 60%
├─ 平均盈利 = ¥500
├─ 平均亏损 = ¥300
└─ 盈亏比 b = 500/300 = 1.67
凯利仓位:
f* = 0.6 - (0.4 / 1.67) = 0.6 - 0.24 = 0.36 = 36%实战中的修正:
凯利公式过于激进,实际使用分数凯利(Fractional Kelly):
def kelly_criterion(win_prob: float, win_loss_ratio: float,
fraction: float = 0.25) -> float:
"""
凯利公式仓位管理
Args:
win_prob: 胜率(0-1)
win_loss_ratio: 盈亏比(平均盈利/平均亏损)
fraction: 凯利系数(0.25-0.5),降低风险
Returns:
建议仓位比例
"""
# 完整凯利仓位
kelly = win_prob - (1 - win_prob) / win_loss_ratio
# 分数凯利
adjusted_kelly = max(kelly, 0) * fraction
# 限制最大仓位
adjusted_kelly = min(adjusted_kelly, 0.5)
return adjusted_kelly
## 使用
position = kelly_criterion(win_prob=0.6, win_loss_ratio=1.67, fraction=0.25)
print(f"建议仓位: {position:.1%}")凯利公式的局限性:
| 局限 | 说明 | 解决方法 |
|---|---|---|
| 需要准确的p和b | 历史数据不代表未来 | 保守估计参数 |
| 波动巨大 | 满仓凯利风险极高 | 使用分数凯利(0.25-0.5) |
| 不考虑回撤 | 可能导致大幅回撤 | 结合最大回撤限制 |
6.3.3 风险平价(Risk Parity)
核心思想:每个资产贡献相同的风险。
- :资产i的权重
- :资产i的波动率
原理:波动率高的资产配置少,波动率低的资产配置多。
def risk_parity_weights(volatilities: np.array) -> np.array:
"""
风险平价权重计算
Args:
volatilities: 各资产的波动率数组
Returns:
各资产的权重
"""
# 权重与波动率成反比
inv_vol = 1 / volatilities
weights = inv_vol / inv_vol.sum()
return weights
## 使用
vols = np.array([0.15, 0.20, 0.25]) # 三个资产的年化波动率
weights = risk_parity_weights(vols)
print("风险平价权重:")
for i, w in enumerate(weights):
print(f"资产{i+1} (波动率{vols[i]:.0%}): {w:.1%}")6.4 止损止盈策略
6.4.1 固定百分比止损
原理:价格跌破入场价一定比例时平仓。
def fixed_stop_loss(entry_price: float, stop_pct: float = 0.05) -> float:
"""固定百分比止损"""
return entry_price * (1 - stop_pct)
entry = 100.0
stop = fixed_stop_loss(entry, 0.05)
print(f"入场价: ¥{entry}, 止损价: ¥{stop}")优点:简单明确
缺点:未考虑波动率,可能过早止损
6.4.2 ATR动态止损
原理:根据市场波动率(ATR)设置止损。
通常
def atr_stop_loss(entry_price: float, atr: float, multiplier: float = 2.0) -> float:
"""基于ATR的动态止损"""
return entry_price - multiplier * atr
entry = 100.0
atr = 3.0
stop = atr_stop_loss(entry, atr, multiplier=2.5)
print(f"入场价: ¥{entry}, ATR: {atr}, 止损价: ¥{stop:.2f}")优点:适应市场波动
缺点:波动大时止损位宽,风险大
6.4.3 移动止损(Trailing Stop)
原理:跟随价格上涨而上移止损位,锁定利润。
class TrailingStopManager:
"""移动止损管理"""
def __init__(self, initial_stop_pct: float = 0.05,
trailing_pct: float = 0.08):
self.initial_stop_pct = initial_stop_pct
self.trailing_pct = trailing_pct
self.entry_price = None
self.highest_price = None
self.current_stop = None
def open_position(self, entry_price: float):
"""开仓"""
self.entry_price = entry_price
self.highest_price = entry_price
self.current_stop = entry_price * (1 - self.initial_stop_pct)
print(f"✅ 开仓: 价格 ¥{entry_price:.2f}, 初始止损 ¥{self.current_stop:.2f}")
def update(self, current_price: float) -> tuple:
"""
更新止损位
Returns:
(should_close, stop_price)
"""
# 更新最高价
if current_price > self.highest_price:
self.highest_price = current_price
# 更新移动止损
new_stop = self.highest_price * (1 - self.trailing_pct)
# 止损只能上移,不能下移
if new_stop > self.current_stop:
self.current_stop = new_stop
print(f"📈 止损上移至 ¥{self.current_stop:.2f}")
# 检查是否触发止损
if current_price <= self.current_stop:
return (True, self.current_stop)
return (False, self.current_stop)
## 使用示例
manager = TrailingStopManager(initial_stop_pct=0.05, trailing_pct=0.08)
manager.open_position(100.0)
## 模拟价格变化
prices = [102, 105, 110, 108, 106, 104, 100]
for price in prices:
should_close, stop = manager.update(price)
print(f"当前价: ¥{price}, 止损价: ¥{stop:.2f}, 是否平仓: {should_close}")
if should_close:
print(f"🔴 触发止损,平仓价格: ¥{price}")
break6.5 综合风险管理框架
class RiskManager:
"""综合风险管理系统"""
def __init__(self,
max_position_pct: float = 0.3, # 单只股票最大仓位
max_drawdown_limit: float = 0.20, # 最大回撤限制
stop_loss_pct: float = 0.05, # 止损比例
use_kelly: bool = True): # 是否使用凯利公式
self.max_position_pct = max_position_pct
self.max_drawdown_limit = max_drawdown_limit
self.stop_loss_pct = stop_loss_pct
self.use_kelly = use_kelly
self.peak_value = 0
self.positions = {}
def calculate_position_size(self, capital: float, price: float,
win_prob: float = None,
win_loss_ratio: float = None) -> int:
"""计算仓位大小"""
if self.use_kelly and win_prob and win_loss_ratio:
# 凯利公式
kelly_pct = kelly_criterion(win_prob, win_loss_ratio, fraction=0.25)
position_value = capital * kelly_pct
else:
# 固定比例
position_value = capital * self.max_position_pct
# 计算股数(整手)
shares = int(position_value / price / 100) * 100
return shares
def check_drawdown(self, current_value: float) -> bool:
"""检查是否超过最大回撤限制"""
self.peak_value = max(self.peak_value, current_value)
drawdown = (self.peak_value - current_value) / self.peak_value
if drawdown > self.max_drawdown_limit:
print(f"⚠️ 最大回撤 {drawdown:.1%} 超过限制 {self.max_drawdown_limit:.1%}")
return True
return False
def add_position(self, stock_code: str, entry_price: float, shares: int):
"""添加持仓(设置止损)"""
stop_price = entry_price * (1 - self.stop_loss_pct)
self.positions[stock_code] = {
'entry_price': entry_price,
'shares': shares,
'stop_price': stop_price
}
print(f"✅ 开仓 {stock_code}: {shares}股 @ ¥{entry_price}, 止损 ¥{stop_price:.2f}")
def check_stop_loss(self, stock_code: str, current_price: float) -> bool:
"""检查止损"""
if stock_code not in self.positions:
return False
position = self.positions[stock_code]
if current_price <= position['stop_price']:
print(f"🔴 {stock_code} 触发止损: 当前价 ¥{current_price} <= 止损价 ¥{position['stop_price']:.2f}")
return True
return False
## 使用示例
rm = RiskManager(
max_position_pct=0.3,
max_drawdown_limit=0.20,
stop_loss_pct=0.05,
use_kelly=True
)
## 计算仓位
capital = 100000
price = 50.0
shares = rm.calculate_position_size(capital, price, win_prob=0.6, win_loss_ratio=1.5)
print(f"建议买入: {shares} 股")
## 开仓
rm.add_position('000001', price, shares)
## 检查止损
rm.check_stop_loss('000001', 48.0)完整风险管理示例:
class RiskManager:
"""完整的风险管理框架"""
def __init__(self, stop_loss_pct=0.05, take_profit_pct=0.15, trailing_stop_pct=0.08):
self.stop_loss_pct = stop_loss_pct # 止损比例
self.take_profit_pct = take_profit_pct # 止盈比例
self.trailing_stop_pct = trailing_stop_pct # 移动止损比例
self.entry_price = None
self.highest_price = None
def open_position(self, price: float):
"""开仓"""
self.entry_price = price
self.highest_price = price
print(f"开仓价格: {price:.2f}")
print(f"止损价格: {price * (1 - self.stop_loss_pct):.2f}")
print(f"止盈价格: {price * (1 + self.take_profit_pct):.2f}")
def check_close(self, current_price: float) -> tuple:
"""
检查是否应该平仓
Returns:
(should_close, reason)
"""
if self.entry_price is None:
return (False, "无持仓")
# 更新最高价(用于移动止损)
self.highest_price = max(self.highest_price, current_price)
# 计算止损价格
stop_loss_price = self.entry_price * (1 - self.stop_loss_pct)
# 计算止盈价格
take_profit_price = self.entry_price * (1 + self.take_profit_pct)
# 计算移动止损价格
trailing_stop_price = self.highest_price * (1 - self.trailing_stop_pct)
# 检查止损
if current_price <= stop_loss_price:
return (True, f"止损触发 (价格: {current_price:.2f})")
# 检查止盈
if current_price >= take_profit_price:
return (True, f"止盈触发 (价格: {current_price:.2f})")
# 检查移动止损
if trailing_stop_price > self.entry_price and current_price <= trailing_stop_price:
return (True, f"移动止损触发 (价格: {current_price:.2f})")
return (False, "持仓中")
## 使用
risk_mgr = RiskManager(stop_loss_pct=0.05, take_profit_pct=0.15)
risk_mgr.open_position(10.0)
should_close, reason = risk_mgr.check_close(9.8)
print(f"是否平仓: {should_close}, 原因: {reason}")六、策略优化与参数调优
6.1 网格搜索
from itertools import product
import pandas as pd
def grid_search(df: pd.DataFrame, fast_periods: list, slow_periods: list,
initial_capital: float = 100000) -> pd.DataFrame:
"""网格搜索最优参数"""
results = []
for fast, slow in product(fast_periods, slow_periods):
if fast >= slow:
continue # 快线不能慢于慢线
# 创建策略
strategy = DualMAStrategy(fast_period=fast, slow_period=slow)
# 回测
result = strategy.backtest(df, initial_capital)
# 记录结果
results.append({
'fast_period': fast,
'slow_period': slow,
'final_value': result['final_value'],
'return': result['strategy_return'],
'excess_return': result['excess_return']
})
results_df = pd.DataFrame(results)
# 按收益排序
results_df = results_df.sort_values('excess_return', ascending=False)
return results_df
## 使用
results = grid_search(df_clean,
fast_periods=[5, 10, 15],
slow_periods=[20, 30, 40, 60])
print(results.head())6.2 随机搜索
import random
def random_search(df: pd.DataFrame, n_iterations: int = 100,
fast_range: tuple = (5, 20),
slow_range: tuple = (20, 80)) -> pd.DataFrame:
"""随机搜索"""
results = []
for _ in range(n_iterations):
# 随机生成参数
fast = random.randint(*fast_range)
slow = random.randint(*slow_range)
if fast >= slow:
continue
# 回测
strategy = DualMAStrategy(fast_period=fast, slow_period=slow)
result = strategy.backtest(df)
results.append({
'fast_period': fast,
'slow_period': slow,
'final_value': result['final_value'],
'return': result['strategy_return'],
'excess_return': result['excess_return']
})
return pd.DataFrame(results).sort_values('excess_return', ascending=False)
## 使用
results = random_search(df_clean, n_iterations=50)
print(results.head())七、实盘交易对接
7.1 实盘对接方案
| 平台 | 市场覆盖 | API 类型 | 难度 |
|---|---|---|---|
| QMT/miniQMT | A股、期货 | Python/C++ | ⭐⭐ |
| TqSdk | 期货、期权 | Python | ⭐⭐⭐ |
| 聚宽 | A股 | Python | ⭐ |
| Uqer | A股、港股 | Python | ⭐⭐ |
| VeighNa | 多市场 | Python/C# | ⭐⭐⭐⭐ |
| CTP | 期货 | C++/Python | ⭐⭐⭐⭐⭐ |
7.2 QMT 实盘对接示例
## 注意:QMT 需要开通券商账户并安装客户端
from xtquant import xttrader
class QMTTrader:
"""QMT 实盘交易"""
def __init__(self, session_id: int, account_id: str):
self.session_id = session_id
self.account_id = account_id
self.trader = xttrader.XtTrader(session_id, account_id)
def get_position(self):
"""查询持仓"""
positions = self.trader.query_stock_positions(self.account_id)
return positions
def get_account(self):
"""查询账户"""
account = self.trader.query_stock_asset(self.account_id)
return account
def buy(self, stock_code: str, price: float, volume: int):
"""买入"""
order_id = self.trader.order_stock(
account=self.account_id,
stock_code=stock_code,
order_type=xttrader.STOCK_BUY,
order_volume=volume,
price_type=xttrader.FIX_PRICE,
price=price
)
return order_id
def sell(self, stock_code: str, price: float, volume: int):
"""卖出"""
order_id = self.trader.order_stock(
account=self.account_id,
stock_code=stock_code,
order_type=xttrader.STOCK_SELL,
order_volume=volume,
price_type=xttrader.FIX_PRICE,
price=price
)
return order_id7.3 实盘风控框架
import time
from datetime import datetime
class LiveTrading:
"""实盘交易"""
def __init__(self, trader, strategy, risk_manager):
self.trader = trader # 交易接口
self.strategy = strategy # 交易策略
self.risk_manager = risk_manager # 风险管理
self.is_running = False
def on_tick(self, tick_data: dict):
"""每个tick调用"""
stock_code = tick_data['stock_code']
price = tick_data['price']
# 获取策略信号
signal = self.strategy.get_signal(stock_code, price)
# 获取当前持仓
position = self.trader.get_position(stock_code)
# 买入信号且无持仓
if signal == 1 and position is None:
# 计算仓位
account = self.trader.get_account()
capital = account['total_asset']
volume = self.risk_manager.calculate_volume(capital, price)
if volume > 0:
self.trader.buy(stock_code, price, volume)
print(f"{datetime.now()}: 买入 {stock_code} {volume}股 @ {price}")
# 卖出信号或有持仓
elif signal == -1 and position is not None:
should_close, reason = self.risk_manager.check_close(price)
if should_close:
self.trader.sell(stock_code, price, position['volume'])
print(f"{datetime.now()}: 卖出 {stock_code} {position['volume']}股 @ {price}, {reason}")
def run(self):
"""运行实盘"""
self.is_running = True
try:
while self.is_running:
# 获取行情数据
tick_data = self.get_market_data()
if tick_data:
self.on_tick(tick_data)
time.sleep(1) # 1秒检查一次
except KeyboardInterrupt:
print("停止实盘交易")
except Exception as e:
print(f"实盘交易异常: {e}")
finally:
self.is_running = False八、进阶策略
8.1 均值回归策略
class MeanReversionStrategy:
"""均值回归策略"""
def __init__(self, lookback: int = 20, entry_std: float = 2.0,
exit_std: float = 0.5):
self.lookback = lookback
self.entry_std = entry_std
self.exit_std = exit_std
def generate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
"""生成信号"""
df = df.copy()
# 计算均线和标准差
df['mean'] = df['close'].rolling(self.lookback).mean()
df['std'] = df['close'].rolling(self.lookback).std()
# 计算 Z-score
df['z_score'] = (df['close'] - df['mean']) / df['std']
# 生成信号
# 价格低于均值2倍标准差时买入
df['signal'] = 0
df.loc[df['z_score'] < -self.entry_std, 'signal'] = 1
# 价格回归到均值附近时平仓
df.loc[abs(df['z_score']) < self.exit_std, 'signal'] = -1
df['position'] = df['signal'].replace(0, method='ffill').fillna(0)
return df8.2 突破策略
class BreakoutStrategy:
"""突破策略"""
def __init__(self, lookback: int = 20, atr_multiple: float = 3.0):
self.lookback = lookback
self.atr_multiple = atr_multiple
def generate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
"""生成信号"""
df = df.copy()
# 计算最高最低价
df['highest'] = df['high'].rolling(self.lookback).max()
df['lowest'] = df['low'].rolling(self.lookback).min()
# 计算 ATR
df['ATR'] = talib.ATR(df['high'].values, df['low'].values,
df['close'].values, timeperiod=14)
# 突破信号
df['signal'] = 0
df.loc[df['close'] > df['highest'].shift(1), 'signal'] = 1 # 向上突破
df.loc[df['close'] < df['lowest'].shift(1), 'signal'] = -1 # 向下突破
df['position'] = df['signal'].replace(0, method='ffill').fillna(0)
return df8.3 机器学习策略
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
class MLStrategy:
"""机器学习策略"""
def __init__(self, lookback: int = 20, prediction_horizon: int = 5):
self.lookback = lookback
self.prediction_horizon = prediction_horizon
self.model = RandomForestClassifier(n_estimators=100, random_state=42)
self.is_trained = False
def prepare_features(self, df: pd.DataFrame) -> pd.DataFrame:
"""准备特征"""
df = df.copy()
# 价格特征
df['return_1'] = df['close'].pct_change(1)
df['return_5'] = df['close'].pct_change(5)
df['return_10'] = df['close'].pct_change(10)
# 技术指标
df['RSI'] = talib.RSI(df['close'].values, timeperiod=14)
df['MACD'], _, _ = talib.MACD(df['close'].values)
# 波动率
df['volatility'] = df['close'].pct_change().rolling(20).std()
# 目标变量
df['target'] = (df['close'].shift(-self.prediction_horizon) >
df['close']).astype(int)
# 删除缺失值
df.dropna(inplace=True)
return df
def train(self, df: pd.DataFrame):
"""训练模型"""
df_features = self.prepare_features(df)
# 特征列
feature_cols = ['return_1', 'return_5', 'return_10',
'RSI', 'MACD', 'volatility']
X = df_features[feature_cols]
y = df_features['target']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, shuffle=False
)
# 训练
self.model.fit(X_train, y_train)
# 评估
y_pred = self.model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"训练完成,测试集准确率: {accuracy:.2%}")
self.is_trained = True
def predict(self, df: pd.DataFrame) -> pd.DataFrame:
"""预测信号"""
if not self.is_trained:
raise Exception("模型未训练")
df_features = self.prepare_features(df)
feature_cols = ['return_1', 'return_5', 'return_10',
'RSI', 'MACD', 'volatility']
# 预测
df_features['prediction'] = self.model.predict(df_features[feature_cols])
# 转换为交易信号
df_features['signal'] = 0
df_features.loc[df_features['prediction'] == 1, 'signal'] = 1
df_features.loc[df_features['prediction'] == 0, 'signal'] = -1
return df_features九、监控与运维
9.1 策略监控
import time
import smtplib
from email.mime.text import MIMEText
class StrategyMonitor:
"""策略监控"""
def __init__(self, email_config: dict):
self.email_config = email_config
def check_strategy_health(self, strategy) -> dict:
"""检查策略健康度"""
metrics = {
'total_trades': strategy.total_trades,
'win_rate': strategy.win_rate,
'current_pnl': strategy.current_pnl,
'max_drawdown': strategy.max_drawdown,
'last_signal_time': strategy.last_signal_time
}
return metrics
def send_alert(self, subject: str, content: str):
"""发送告警邮件"""
msg = MIMEText(content, 'plain', 'utf-8')
msg['Subject'] = subject
msg['From'] = self.email_config['sender']
msg['To'] = self.email_config['receiver']
with smtplib.SMTP(self.email_config['smtp_server'],
self.email_config['smtp_port']) as server:
server.starttls()
server.login(self.email_config['sender'],
self.email_config['password'])
server.sendmail(msg['From'], [msg['To']], msg.as_string())
def monitor(self, strategy, check_interval: int = 300):
"""持续监控"""
while True:
metrics = self.check_strategy_health(strategy)
# 检查异常
alerts = []
if metrics['win_rate'] < 0.4: # 胜率过低
alerts.append(f"胜率过低: {metrics['win_rate']:.2%}")
if metrics['max_drawdown'] < -0.15: # 回撤过大
alerts.append(f"回撤过大: {metrics['max_drawdown']:.2%}")
# 发送告警
if alerts:
content = "\n".join(alerts)
self.send_alert("策略异常告警", content)
time.sleep(check_interval)9.2 日志管理
import logging
from logging.handlers import RotatingFileHandler
import json
class TradingLogger:
"""交易日志"""
def __init__(self, log_file: str = 'trading.log'):
self.logger = logging.getLogger('Trading')
self.logger.setLevel(logging.INFO)
# 文件处理器
file_handler = RotatingFileHandler(
log_file, maxBytes=10*1024*1024, backupCount=5
)
file_handler.setLevel(logging.INFO)
# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# 格式化
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
self.logger.addHandler(file_handler)
self.logger.addHandler(console_handler)
def log_trade(self, action: str, stock_code: str, price: float,
volume: int, timestamp: str = None):
"""记录交易"""
trade_log = {
'action': action,
'stock_code': stock_code,
'price': price,
'volume': volume,
'timestamp': timestamp or datetime.now().isoformat()
}
self.logger.info(f"交易: {json.dumps(trade_log, ensure_ascii=False)}")
def log_signal(self, stock_code: str, signal: int, price: float):
"""记录信号"""
self.logger.info(f"信号: {stock_code}, {signal}, 价格: {price}")
def log_error(self, error: str):
"""记录错误"""
self.logger.error(f"错误: {error}")十、最佳实践
10.1 策略开发原则
| 原则 | 说明 |
|---|---|
| 简单有效 | 策略越简单,越容易理解和维护 |
| 风险优先 | 优先考虑亏损控制,而非收益最大化 |
| 参数优化 | 避免过度拟合,使用样本外测试 |
| 多样化 | 不要只依赖单一策略或指标 |
| 持续监控 | 定期检查策略表现,及时调整 |
10.2 常见陷阱
| 陷阱 | 说明 | 避免方法 |
|---|---|---|
| 过拟合 | 回测表现好,实盘差 | 样本外测试、参数范围约束 |
| 幸存者偏差 | 只看成功案例 | 全市场测试 |
| 前视偏差 | 使用未来数据 | 严格按时间顺序处理 |
| 交易成本忽略 | 手续费、滑点 | 回测中加入成本 |
| 数据质量问题 | 缺失、错误 | 数据清洗、质量检查 |
10.3 配置管理
import yaml
from dataclasses import dataclass
from typing import List
@dataclass
class StrategyConfig:
"""策略配置"""
strategy_type: str
parameters: dict
risk_params: dict
@classmethod
def from_yaml(cls, config_file: str):
"""从 YAML 加载配置"""
with open(config_file, 'r', encoding='utf-8') as f:
config_data = yaml.safe_load(f)
return cls(**config_data)
## config.yaml
## strategy_type: "dual_ma"
## parameters:
## fast_period: 5
## slow_period: 20
## risk_params:
## stop_loss: 0.05
## take_profit: 0.15
## position_ratio: 0.3
## 使用
config = StrategyConfig.from_yaml('config.yaml')附录:核心资源
## 一键安装核心库
pip install numpy pandas akshare talib backtrader matplotlib推荐文档:
教程结束 | 持续更新中...
作者:寒枫
版本:1.0
最后更新:2024