Pandas on 远思码技术实验室

向量化回测引擎：从零实现一个可信的日频回测框架

Sat, 17 Oct 2026 20:40:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

回测是量化研究里最容易产生幻觉的一步。同样一段策略逻辑，用不同框架、不同参数假设跑出来的年化收益率可以差出十几个点，而绝大多数差异都藏在三件小事里：成交价、交易限制、成本。

实验室的结论是：先自己写一个能看懂每一行的引擎，再去用现成框架。这篇就是那个引擎，全部代码不到 200 行。

一、引擎的契约

在写代码之前，先把输入输出定死，这是防止自己作弊的第一步：

输入	形状	含义
`close`	T×N	复权收盘价矩阵
`volume`	T×N	成交量矩阵（用于判断可交易性）
`pct_chg`	T×N	当日涨跌幅，用于判断涨跌停
`target_w`	T×N	T 日收盘后决定的下一期目标权重，行和 ≤ 1，余下为现金

输出	含义
`nav`	净值曲线（起点为 1）
`holdings`	每日实际持仓权重、换手、成本明细

关键约定只有一条：target_w 的第 t 行，是从第 t 日收盘之后开始生效的权重。引擎内部自己做 shift(1) 来实现"信号滞后一期"，策略代码里严禁再手动 shift，否则会重复滞后。

二、骨架：收益、漂移、成本

# backtest/engine.py
from __future__ import annotations

import itertools
from dataclasses import dataclass, field

import numpy as np
import pandas as pd


@dataclass
class BacktestConfig:
 fee_rate: float = 0.0003 # 佣金，双边
 stamp_duty: float = 0.0005 # 印花税，仅卖出
 slippage: float = 0.0010 # 单边滑点
 impact_coef: float = 0.0015 # 冲击成本系数（相对换手）
 rf: float = 0.02 # 无风险利率（年化）
 periods: int = 244 # 年化交易日


@dataclass
class BacktestResult:
 nav: pd.Series
 daily_return: pd.Series
 turnover: pd.Series
 cost: pd.Series
 holdings: pd.DataFrame
 metrics: dict = field(default_factory=dict)

核心循环全部用矩阵运算完成，一行 for 都不需要：

def run_backtest(close: pd.DataFrame,
 volume: pd.DataFrame,
 target_w: pd.DataFrame,
 pct_chg: pd.DataFrame | None = None,
 cfg: BacktestConfig | None = None) -> BacktestResult:
 cfg = cfg or BacktestConfig()
 close, volume = close.align(volume, join="inner")
 target_w = target_w.reindex(index=close.index, columns=close.columns).fillna(0.0)

 ret = close.pct_change().fillna(0.0) # 第 t 日收益，close_{t-1} -> close_t

 # ---- 1. 可交易性：停牌(volume=0) / 涨跌停 / 缺失价 ----
 tradable = (volume > 0) & close.notna() & (target_w.notna())
 if pct_chg is not None:
 pct = pct_chg.reindex_like(tradable)
 # 主板 ±10%、创业板/科创板 ±20%，用绝对阈值统一近似：≥9.8% 视为涨停不可买
 limit_up = pct >= 9.8
 limit_down = pct <= -9.8
 # 目标权重 > 0 且涨停 -> 买不进；目标权重 < 0 且跌停 -> 卖不出
 can_buy = tradable & ~limit_up
 can_sell = tradable & ~limit_down
 w_prev = target_w.shift(1)
 blocked_buy = (w_prev.isna() | (w_prev <= 0)) & (target_w > 0) & ~can_buy
 blocked_sell = (w_prev > 0) & (target_w <= 0) & ~can_sell
 target_w = target_w.mask(blocked_buy, 0.0).mask(blocked_sell, w_prev)

 # ---- 2. 归一化：不足 1 的部分视为现金 ----
 # 允许做多为主；若行和 > 1 则等比压缩，避免隐式杠杆
 gross = target_w.sum(axis=1).replace(0, np.nan)
 scale = np.where(gross > 1, 1 / gross, 1.0)
 target_w = target_w.mul(pd.Series(scale, index=target_w.index), axis=0).fillna(0.0)

 # ---- 3. 实际持仓 = 上一期目标权重（信号滞后一期） ----
 w_hold = target_w.shift(1).fillna(0.0)

 # ---- 4. 毛收益：今日持仓 × 今日收益 ----
 gross_ret = (w_hold * ret).sum(axis=1)

 # ---- 5. 权重漂移：今日收盘后各资产权重自然变化 ----
 denom = (1 + gross_ret).replace(0, np.nan)
 w_drift = w_hold.mul(1 + ret, axis=0).div(denom, axis=0).fillna(0.0)

 # ---- 6. 换手与成本：今日收盘调仓，相对漂移权重 ----
 delta = target_w - w_drift
 turnover_buy = delta.clip(lower=0).sum(axis=1) # 买入额占比
 turnover_sell = (-delta).clip(lower=0).sum(axis=1) # 卖出额占比
 turnover = turnover_buy + turnover_sell

 cost = (turnover_buy * (cfg.fee_rate + cfg.slippage)
 + turnover_sell * (cfg.fee_rate + cfg.slippage + cfg.stamp_duty)
 + turnover * cfg.impact_coef * turnover) # 冲击成本近似平方项

 port_ret = gross_ret - cost
 nav = (1 + port_ret).cumprod()

 res = BacktestResult(nav=nav, daily_return=port_ret, turnover=turnover,
 cost=cost, holdings=w_hold)
 res.metrics = performance(nav, port_ret, turnover, cfg)
 return res

有几处设计值得展开说：

w_hold = target_w.shift(1) 就是"信号滞后一期"的全部实现。策略在 T 日收盘后生成信号，T+1 日才能享受（或承受）收益。
漂移权重 w_drift 常被忽略。如果你 T 日满仓买入，T+1 日股票涨了 5%，那么 T+1 收盘时它在组合里的权重是 5% 之后的自然权重，不是当初的目标权重。调仓换手必须相对它算，否则每次调仓的换手都会被高估。
冲击成本写成 turnover * coef * turnover，即随换手平方增长。这比线性模型更贴近现实：大额调仓的边际成本上升。

三、绩效指标

def performance(nav: pd.Series, ret: pd.Series, turnover: pd.Series,
 cfg: BacktestConfig) -> dict:
 n = len(nav)
 if n < 2 or nav.iloc[-1] <= 0:
 return {"error": "样本不足或净值归零"}
 ann = nav.iloc[-1] ** (cfg.periods / n) - 1
 vol = ret.std(ddof=1) * np.sqrt(cfg.periods)
 sharpe = (ann - cfg.rf) / vol if vol else np.nan

 dd = nav / nav.cummax() - 1
 mdd = dd.min()
 calmar = ann / abs(mdd) if mdd else np.nan
 # 最大回撤持续天数（净值在水面之下的最长连续区间）
 underwater = (dd < 0).astype(int)
 max_flat = max((len(list(g)) for k, g in itertools.groupby(underwater) if k == 1),
 default=0)

 win = (ret > 0).mean()
 avg_turnover = turnover.mean()
 return {
 "累计收益": round(float(nav.iloc[-1] - 1), 4),
 "年化收益": round(float(ann), 4),
 "年化波动": round(float(vol), 4),
 "夏普": round(float(sharpe), 3),
 "最大回撤": round(float(mdd), 4),
 "最大回撤天数": int(max_flat),
 "Calmar": round(float(calmar), 3),
 "日胜率": round(float(win), 3),
 "日均换手": round(float(avg_turnover), 4),
 "年化换手": round(float(avg_turnover * cfg.periods), 2),
 "交易日数": int(n),
 }

这里 日均换手 × 244 = 年化换手 是个粗略但足够用的口径。日频策略年化换手超过 30 倍，成本假设就必须认真对待，不能再用"万一三"敷衍过去。

四、把正确性钉死：三个单元测试

引擎写完不测，等于没写。实验室用三个手算案例做回归测试，任何改动都必须过：

# tests/test_engine.py
import numpy as np
import pandas as pd
from backtest.engine import BacktestConfig, run_backtest

def _frames(ret_rows):
 """由收益矩阵构造价格矩阵（起点 10 元）。"""
 close = (1 + pd.DataFrame(ret_rows)).cumprod() * 10
 volume = pd.DataFrame(1e6, index=close.index, columns=close.columns)
 return close, volume


def test_single_stock_buy_and_hold():
 # 两天，每天涨 10%。T日收盘建仓 -> T+1 才吃到收益
 close, volume = _frames([[0.10], [0.10]])
 w = pd.DataFrame([[1.0], [1.0]], index=close.index, columns=close.columns)
 res = run_backtest(close, volume, w, cfg=BacktestConfig(fee_rate=0, stamp_duty=0,
 slippage=0, impact_coef=0))
 # 第一天无持仓（w 被 shift），第二天满仓吃 10%
 assert abs(res.nav.iloc[0] - 1.0) < 1e-12
 assert abs(res.nav.iloc[1] - 1.10) < 1e-12


def test_cost_is_charged_on_turnover():
 close, volume = _frames([[0.0], [0.0]])
 w = pd.DataFrame([[1.0], [0.0]], index=close.index, columns=close.columns)
 cfg = BacktestConfig(fee_rate=0.001, stamp_duty=0.001, slippage=0, impact_coef=0)
 res = run_backtest(close, volume, w, cfg=cfg)
 # 第一天：w.shift 后仍为 0 -> 无持仓；第二天持仓 1 后立刻清仓？
 # 实际：hold 恒为 [0, 1]，故第二天收盘换手 = 1，卖出成本 = 1*(佣金0.001+印花税0.001)
 assert res.turnover.iloc[1] == 1.0
 assert abs(res.cost.iloc[1] - 0.002) < 1e-12


def test_weights_never_imply_leverage():
 close, volume = _frames([[0.01], [0.01], [0.01]], )
 w = pd.DataFrame([[0.8], [0.8], [0.8]], index=close.index, columns=close.columns)
 res = run_backtest(close, volume, w, cfg=BacktestConfig(fee_rate=0, stamp_duty=0,
 slippage=0, impact_coef=0))
 assert (res.holdings.sum(axis=1) <= 1 + 1e-9).all()

第二个测试看起来有点绕，但它锁住了一个非常具体的语义：换手发生在"目标权重与漂移权重不一致"的那一天，成本当天计提。这个语义一旦写错，所有策略的成本都会被系统性低估。

五、什么时候该换成事件驱动框架

向量化引擎的假设是：同一时点所有股票都能按收盘价成交，且份额可以无限细分。它在下列场景会失真：

场景	向量化引擎的问题	建议
分钟级 / 盘口撮合	无法表达排队、部分成交	事件驱动（vn.py / backtrader / 自研撮合）
资金量大于标的日成交额的 1%	冲击成本模型过于乐观	引入成交量参与率约束
需要盘中撤单、止损单	无订单生命周期	事件驱动
组合再平衡涉及资金约束（现金不足）	权重假设掩盖了资金不足	加现金约束层

实验室的日常研究 90% 用向量化，因为要跑几千组参数；只有在策略进入仿真阶段，才用事件驱动复核一遍。先用快而粗糙的尺子找方向，再用慢而精确的尺子确认。

六、一个常见误用

有人会把 target_w 直接设成"今天涨得最好的股票"，然后跑出 500% 的年化——因为他在 T 日收盘时用了 T 日的数据去选股，而引擎的 shift(1) 让这份"未来信息"合法化了。

判断方法很简单：把 shift(1) 改成 shift(2)，如果年化收益暴跌，说明策略严重依赖即时信息，值得警惕。

结语

到这里我们有了两样东西：可检验的因子，和可信的尺子。下一篇用它们跑第一个真实策略——双均线与动量轮动的组合，顺带把参数稳健性检验做完。

远思为径，码动价值。回测是用来证伪的，不是用来给自己发奖金的。

因子工程实战：从行情数据到可检验的 Alpha 因子

Mon, 12 Oct 2026 20:10:00 +0800

远思为径，码动价值。欢迎来到远思码技术实验室的最新技术实践记录。

在上一篇数据抓取里，我们已经把 A 股日线行情写进了 TimescaleDB 的超表。但干净的数据不等于可用的信号——从"能取到数据"到"能下单"，中间隔着整个因子工程。

这篇文章把我们实验室的因子流水线拆开讲：怎么写、怎么校验、怎么避免自己骗自己。

一、先立四条纪律

因子工程里绝大多数翻车，不是因为数学不够花哨，而是因为违反了下面前四条之一：

不使用未来信息。T 日收盘后才能拿到的数据，只能在 T 日收盘后生成信号，T+1 开盘执行。任何 center=True 的滚动窗口、任何全样本拟合的标准化，都是未来函数。
截面可比。因子值必须在同一个交易日的横截面上做标准化，而不是用时间序列均值。
可复现。因子定义、参数、数据版本都写进代码与因子表，重跑必须得到同样的数字。
可检验。一个因子在入库前必须回答两个问题：它对未来收益有没有单调信息（IC / 分层），扣掉成本后还剩多少（换手）。

第 4 条最容易被跳过，而它恰好是唯一真正重要的一条。

二、取数：把宽表拉成矩阵

实验室的行情表结构在上一篇文章里已经建好，核心字段是 symbol / trade_date / close / volume / amount / turnover / pct_chg。因子计算更适合"矩阵"而不是"长表"，所以第一步先 pivot：

# src/data/market.py
from __future__ import annotations

import pandas as pd
from sqlalchemy import create_engine

DSN = "postgresql+psycopg2://quant:quant@127.0.0.1:5432/quant"


def load_price_matrix(start: str, end: str, engine=None) -> dict[str, pd.DataFrame]:
 """返回 {'close','volume','amount','turnover','pct_chg'} 五张 T×N 矩阵。"""
 engine = engine or create_engine(DSN, pool_pre_ping=True, pool_size=4)
 sql = """
 SELECT symbol, trade_date, close, volume, amount, turnover, pct_chg
 FROM daily_bar
 WHERE trade_date BETWEEN %(start)s AND %(end)s
 ORDER BY trade_date, symbol
 """
 df = pd.read_sql(sql, engine, params={"start": start, "end": end})

 out: dict[str, pd.DataFrame] = {}
 for col in ["close", "volume", "amount", "turnover", "pct_chg"]:
 out[col] = df.pivot(index="trade_date", columns="symbol", values=col).sort_index()
 # 停牌日通常缺失，这里保留 NaN：后续因子计算里 NaN 会自然传播成"不可交易"
 return out

两个细节值得强调：

不要 fillna(method="ffill") 无脑填充。停牌日的价格是"没有成交"，强行前向填充会让动量因子把停牌期算成 0 收益，回测里会凭空产生收益。
矩阵的列（股票）会随时间变化。新股上市、退市都会造成列不对齐，后续用 DataFrame.align 或直接按日截面处理。

三、五个基础因子，先够用再说

不用一上来就上百个因子。实验室的第一版只用了五类，覆盖量价四个维度：

因子	定义	逻辑
`mom_20`	过去 20 日收益	动量效应
`rev_5`	过去 5 日收益取负	短期反转
`vol_20`	20 日收益率标准差取负	低波动异象
`turn_20`	20 日平均换手取负	高换手 = 拥挤
`bias_20`	`close / MA20 - 1` 取负	均值回复

# src/factor/basic.py
import numpy as np
import pandas as pd


def momentum(close: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 """n 日动量：T 日因子 = T 日收盘 / T-n 日收盘 - 1（截止当日，不含未来信息）。"""
 return close / close.shift(n) - 1


def reversal(close: pd.DataFrame, n: int = 5) -> pd.DataFrame:
 return -momentum(close, n)


def volatility(pct: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 # pct_chg 已是百分数，先转成小数
 return -(pct / 100).rolling(n).std()


def turnover_avg(turnover: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 return -turnover.rolling(n).mean()


def bias(close: pd.DataFrame, n: int = 20) -> pd.DataFrame:
 ma = close.rolling(n).mean()
 return -(close / ma - 1)

上面每个因子都只用「截止当日」的数据，这是故意保持的语义：因子定义里不包含任何执行滞后，滞后只在回测引擎里统一做一次。原因很实际——如果因子内部先 shift(1)，回测引擎再叠一层 shift(1)，策略就凭空慢了半拍，收益会被系统性低估；反过来如果某处漏了 shift，又会偷到未来收益。滞后只在一处发生，才方便审计。下一篇的引擎会严格实现这条约定。

四、去极值与标准化：截面处理三步

原始因子值直接进模型会被几只极端值股票带偏。截面处理固定三步：

# src/factor/process.py
import numpy as np
import pandas as pd


def mad_winsorize(df: pd.DataFrame, n: float = 3.0) -> pd.DataFrame:
 """按日截面做 MAD 去极值（中位数 ± n * 1.4826 * MAD）。"""
 med = df.median(axis=1)
 mad = (df.sub(med, axis=0)).abs().median(axis=1) * 1.4826
 upper = med + n * mad
 lower = med - n * mad
 return df.clip(lower=lower, upper=upper, axis=0)


def zscore(df: pd.DataFrame) -> pd.DataFrame:
 """按日截面做 z-score。std=0（全市场同一个值）时返回 0 而不是 inf。"""
 mu = df.mean(axis=1)
 sd = df.std(axis=1).replace(0, np.nan)
 return df.sub(mu, axis=0).div(sd, axis=0)


def industry_neutralize(factor: pd.DataFrame, industry: pd.DataFrame) -> pd.DataFrame:
 """行业中性化：对每个交易日，把因子对行业哑变量做 OLS，取残差。

 industry: 与 factor 同形状的行业标签矩阵（如 "银行"、"电子"），缺失记为 NaN。
 """
 residual = factor.copy() * np.nan
 for date in factor.index:
 y = factor.loc[date]
 g = industry.loc[date]
 mask = y.notna() & g.notna()
 if mask.sum() < 30:
 continue
 dummies = pd.get_dummies(g[mask], drop_first=True, dtype=float)
 if dummies.empty:
 residual.loc[date] = y[mask]
 continue
 X = np.column_stack([np.ones(mask.sum()), dummies.to_numpy()])
 yv = y[mask].to_numpy()
 beta, *_ = np.linalg.lstsq(X, yv, rcond=None)
 residual.loc[date, mask] = yv - X @ beta
 return residual

顺序很重要：先 MAD 去极值 → 再行业中性化 → 最后 z-score。如果先标准化再中性化，残差的量纲会乱，后面做因子加权时权重就失去意义了。

提醒：行业中性化一定会"吃掉"一部分收益。如果你的因子本来就是行业轮动逻辑（比如"超配银行"），中性化之后就只剩行业内选股能力了——这不是坏事，只是要清楚自己在测什么。

五、检验：IC、分层、换手，一个都不能少

因子是否有效，实验室只用三个指标下结论。

5.1 IC 与 ICIR

# src/factor/evaluate.py
import numpy as np
import pandas as pd
from scipy.stats import spearmanr


def forward_return(close: pd.DataFrame, hold: int = 5) -> pd.DataFrame:
 """未来 hold 日收益（用于评价，绝不进入因子计算）。"""
 return close.shift(-hold) / close - 1


def daily_ic(factor: pd.DataFrame, fwd_ret: pd.DataFrame, method: str = "spearman") -> pd.Series:
 """每个交易日横截面上的因子与未来收益的相关性。"""
 ics = {}
 for date in factor.index:
 x, y = factor.loc[date], fwd_ret.loc[date]
 mask = x.notna() & y.notna()
 if mask.sum() < 50:
 continue
 if method == "spearman":
 ics[date] = spearmanr(x[mask], y[mask]).statistic
 else:
 ics[date] = np.corrcoef(x[mask], y[mask])[0, 1]
 return pd.Series(ics).sort_index()


def ic_summary(ic: pd.Series, periods_per_year: int = 244) -> dict:
 ir = ic.mean() / ic.std(ddof=1) if ic.std(ddof=1) else np.nan
 return {
 "IC均值": round(float(ic.mean()), 4),
 "IC标准差": round(float(ic.std(ddof=1)), 4),
 "ICIR": round(float(ir), 3),
 "IC>0占比": round(float((ic > 0).mean()), 3),
 "年化ICIR": round(float(ir * np.sqrt(periods_per_year / 5)), 2) if ir == ir else None,
 "样本天数": int(len(ic)),
 }

经验阈值（日频、5 日持有）：|IC均值| > 0.02、ICIR > 0.3、IC > 0 占比 > 0.55 才值得往下做分层测试。低于这个水平，后面所有回测都只是在拟合噪声。

5.2 分层收益

def layered_return(factor: pd.DataFrame, fwd_ret: pd.DataFrame, q: int = 5) -> pd.DataFrame:
 """按日截面分 q 组，等权持有 forward 收益，返回每组的年化收益。"""
 groups: dict[int, list[float]] = {i: [] for i in range(q)}
 for date in factor.index:
 x, y = factor.loc[date], fwd_ret.loc[date]
 mask = x.notna() & y.notna()
 if mask.sum() < q * 10:
 continue
 labels = pd.qcut(x[mask].rank(method="first"), q, labels=False)
 for g, idx in labels.groupby(labels).groups.items():
 groups[int(g)].append(float(y[mask].loc[idx].mean()))
 annual = {}
 for g, rets in groups.items():
 s = pd.Series(rets)
 annual[f"Q{g + 1}"] = round(float(s.mean() * (244 / 5)), 4) if len(s) else None
 return pd.DataFrame([annual], index=["年化收益"])

一个真正有效的因子，Q1 → Q5 应该单调，并且首尾组年化差异是稳定的，而不是靠某一年撑起来的。

5.3 换手率

IC 再漂亮，如果因子每天把整个组合换个遍，扣完成本就归零。实验室的标准做法是算因子秩的日间自相关来近似换手：

def rank_autocorr(factor: pd.DataFrame, lag: int = 1) -> float:
 """因子截面秩的自相关，越高越稳定（0.9 以上说明换手很低）。"""
 ranks = factor.rank(axis=1, pct=True)
 vals = []
 for date in ranks.index[lag:]:
 a = ranks.loc[date]
 b = ranks.shift(lag).loc[date]
 mask = a.notna() & b.notna()
 if mask.sum() < 50:
 continue
 vals.append(float(np.corrcoef(a[mask], b[mask])[0, 1]))
 return float(np.nanmean(vals))

六、落库：因子表长什么样

因子算完不要停在 notebook 里。实验室统一写入 factor_value 表，主键 (factor_name, trade_date, symbol)，字段 raw / z，外加版本号：

CREATE TABLE IF NOT EXISTS factor_value (
 factor_name text NOT NULL,
 trade_date date NOT NULL,
 symbol text NOT NULL,
 raw double precision,
 z double precision,
 version text NOT NULL DEFAULT 'v1',
 PRIMARY KEY (factor_name, trade_date, symbol)
);

SELECT create_hypertable('factor_value', 'trade_date',
 chunk_time_interval => INTERVAL '90 days',
 if_not_exists => TRUE);

写入时用 ON CONFLICT DO UPDATE 做幂等 upsert，这样重跑某一天的因子不会产生重复行：

from sqlalchemy import text

UPSERT = text("""
 INSERT INTO factor_value (factor_name, trade_date, symbol, raw, z, version)
 VALUES (:factor_name, :trade_date, :symbol, :raw, :z, :version)
 ON CONFLICT (factor_name, trade_date, symbol)
 DO UPDATE SET raw = EXCLUDED.raw, z = EXCLUDED.z, version = EXCLUDED.version
""")

七、几个一定会踩的坑

复权基准会变。前复权价格在每次除权后整体重算，历史因子值会"漂移"。实验室的做法是因子表存未复权价 + 复权因子，复权只在计算时做，并且记录 version。
ST / 退市股没剔除。z 值算对了，但买不进去。因子入库前就该把"不可交易"标出来，别等到回测才过滤。
成分股用的是今天的名单。这是幸存者偏差的经典来源，做指数增强类策略时必须用当期成分股快照。
IC 算的是样本内。因子是全样本算出来的，IC 也是全样本。真正的检验要在滚动窗口里做，下一篇会展开。

结语

到这里，我们有了一个可复现、可检验的因子表。接下来两件事必须按顺序做：先把回测引擎写对，再用它去证伪这些因子——先有可信的尺子，再去量东西。

远思为径，码动价值。数据给了原料，因子给了假设，剩下的交给回测去审判。