# 你的策略回测很赚钱，实盘为什么亏？7 个陷阱逐个拆解

回测年化 30%、夏普 2.5、最大回撤 8%。你兴奋地开了实盘，三个月后一看——亏了 12%。

这不是段子。这是量化新手最普遍的经历。

回测和实盘之间的鸿沟不是因为"市场变了"，而是因为回测里有大量**你没意识到的作弊**。这些作弊不是故意的，而是写代码时的默认假设太理想了。

这篇文章用 AlphaFeed 的数据，把 7 个最常见的陷阱逐个拆解，每个都有代码演示——让你看到"修正前"和"修正后"的收益差距有多大。

## 陷阱 1：用收盘价成交（你买不到收盘价）

这是最常见的回测作弊。你的代码大概率长这样：

```python
# 用收盘价计算信号，又用同一天的收盘价假设成交
df["signal"] = (df["ma20"] > df["ma60"]).astype(int)
df["position"] = df["signal"]  # 今天信号今天就用
df["ret"] = df["close"].pct_change()
df["strategy_ret"] = df["position"] * df["ret"]
```

**问题：** 你在用今天的收盘价做判断，然后假设自己能以今天的收盘价买入。但实际上，收盘价是 15:00 的最后一笔成交——你看到这个价格的时候已经买不到了。

**修正：信号延迟一天。**

```python
df["position"] = df["signal"].shift(1).fillna(0)  # 今天的信号，明天才执行
```

**差距有多大？** 用 AlphaFeed 拉数据跑一下：

```python
import pandas as pd
import numpy as np
from alphafeed import AlphaFeed

af = AlphaFeed()

df = af.klines.get("600519.SH", period="1d", count=1000, adjust="forward", to_dataframe=True)
df = df.sort_values("trade_date").reset_index(drop=True)

df["ma20"] = df["close"].rolling(20).mean()
df["ma60"] = df["close"].rolling(60).mean()
df["signal"] = (df["ma20"] > df["ma60"]).astype(int)
df["ret"] = df["close"].pct_change().fillna(0)

# 作弊版：当天信号当天用
df["cheat_ret"] = df["signal"] * df["ret"]
cheat_equity = (1 + df["cheat_ret"]).cumprod()

# 正确版：信号延迟一天
df["position"] = df["signal"].shift(1).fillna(0)
df["honest_ret"] = df["position"] * df["ret"]
honest_equity = (1 + df["honest_ret"]).cumprod()

print(f"作弊版累计收益: {cheat_equity.iloc[-1] - 1:+.2%}")
print(f"正确版累计收益: {honest_equity.iloc[-1] - 1:+.2%}")
print(f"差距: {(cheat_equity.iloc[-1] - honest_equity.iloc[-1]) / honest_equity.iloc[-1] * 100:.1f}%")
```

光这一个修正，收益可能就缩水 20%–40%。

## 陷阱 2：忽略交易成本（每次交易都在亏钱）

A 股每次交易的真实成本：

| 费用项 | 比例 | 说明 |
| --- | --- | --- |
| 券商佣金 | ~万 2.5（双边） | 买卖各收一次 |
| 印花税 | 千 1（单边） | 只有卖出时收 |
| 合计 | ~千 1.5 / 次 | 买入+卖出一轮 |

看着不多？如果你的策略一年交易 100 次，成本就是 15%。

```python
import pandas as pd
import numpy as np

# 接上面的代码
cost_per_trade = 0.0015  # 单边成本
df["trade"] = df["position"].diff().abs()  # 1 = 发生交易
df["cost"] = df["trade"] * cost_per_trade

df["net_ret"] = df["honest_ret"] - df["cost"]
net_equity = (1 + df["net_ret"]).cumprod()

total_trades = df["trade"].sum()
total_cost = df["cost"].sum()

print(f"总交易次数: {total_trades:.0f}")
print(f"总交易成本: {total_cost:.2%}")
print(f"扣成本前收益: {honest_equity.iloc[-1] - 1:+.2%}")
print(f"扣成本后收益: {net_equity.iloc[-1] - 1:+.2%}")
```

交易频率越高，成本侵蚀越严重。日线级别的均线策略还好，如果你做分钟线策略一天交易 10 次，光成本就能让策略从盈利变亏损。

## 陷阱 3：滑点（你想买 100 元，实际成交 100.5 元）

回测默认以你想要的价格成交。但实际上：

- 你挂 100 元买入，可能成交在 100.2 元
- 你挂 50 元卖出，可能成交在 49.8 元
- 股票越不活跃，滑点越大

用盘口数据估算真实滑点：

```python
from alphafeed import AlphaFeed

af = AlphaFeed()

symbols = ["600519.SH", "000001.SZ", "300750.SZ", "601318.SH"]

for sym in symbols:
    depth = af.depth.get(sym)
    bid1 = depth.bid_prices[0]
    ask1 = depth.ask_prices[0]
    mid = (bid1 + ask1) / 2
    spread_bps = (ask1 - bid1) / mid * 10000

    print(f"{sym}: 买一={bid1:.2f} 卖一={ask1:.2f} 价差={spread_bps:.1f}bps")
```

大盘蓝筹的价差可能只有 2–5 bps（万分之二到五），但小盘股可能有 20–50 bps。如果你的策略选出的全是小盘股，滑点会严重侵蚀收益。

**回测中加入滑点：**

```python
slippage = 0.001  # 假设单边滑点 0.1%
df["net_ret_with_slippage"] = df["honest_ret"] - df["trade"] * (cost_per_trade + slippage)
slippage_equity = (1 + df["net_ret_with_slippage"]).cumprod()

print(f"加滑点后收益: {slippage_equity.iloc[-1] - 1:+.2%}")
```

## 陷阱 4：幸存者偏差（你回测的股票是"活下来"的）

你用今天的沪深 300 成分股做历史回测——但 5 年前的成分股和今天不一样。那些被踢出指数的烂股票，在你的回测里根本没出现过。

更极端的例子：你从不会选到已经退市的股票来回测，因为它们在你的数据里已经不存在了。但在那个时间点，它们是可以被选中的。

**这个问题没有完美的解决方案，但可以缓解：**

- 用更大的股票池做回测，不要只测成分股
- 在回测期开始时的全市场股票池中选股，而不是用今天的列表回溯

```python
from alphafeed import AlphaFeed

af = AlphaFeed()

# 用全市场池做选股，而不是预设的成分股列表
all_cn = af.quotes.get(universes="CN_Stock", to_dataframe=True)
print(f"当前全市场 A 股数量: {len(all_cn)}")

# 在这个基础上按条件筛选，而不是从一个预定义的"好股票列表"开始
```

## 陷阱 5：涨停买不到（信号触发了但你进不去）

A 股涨停后无法买入。你的回测可能会出现这种情况：策略发出买入信号的那天，股票刚好涨停——回测里你完美买入了，但实际上你一手都买不到。

```python
import pandas as pd
from alphafeed import AlphaFeed

af = AlphaFeed()

df = af.klines.get("002594.SZ", period="1d", count=1000, adjust="none", to_dataframe=True)
df = df.sort_values("trade_date").reset_index(drop=True)
df["ret"] = df["close"].pct_change()

# 检查有多少天是涨停（无法买入）
limit_up_days = (df["ret"] >= 0.095).sum()
print(f"涨停天数: {limit_up_days}")
print(f"占比: {limit_up_days / len(df):.1%}")

# 回测修正：涨停日的买入信号应该被跳过
df["can_buy"] = df["ret"] < 0.095  # 涨停日不能买
df["position_corrected"] = df["position"] * df["can_buy"].shift(1).fillna(True).astype(int)
```

同理，跌停日你也卖不出去——回测里你可以止损卖出，但实盘中跌停意味着挂单也卖不掉。

## 陷阱 6：过拟合（参数是"调"出来的，不是"发现"的）

你把均线参数从 (20, 60) 调到 (17, 43)，收益从 15% 涨到 28%。你以为自己发现了更好的参数，实际上你只是在历史数据上做了过拟合。

**检验过拟合的方法：样本外测试。**

```python
import pandas as pd
import numpy as np
from alphafeed import AlphaFeed

af = AlphaFeed()

df = af.klines.get("600519.SH", period="1d", count=2000, adjust="forward", to_dataframe=True)
df = df.sort_values("trade_date").reset_index(drop=True)
df["ret"] = df["close"].pct_change().fillna(0)

# 分成训练集和测试集
split = int(len(df) * 0.6)
train = df.iloc[:split].copy()
test = df.iloc[split:].copy()

def test_strategy(data, short_w, long_w):
    data = data.copy()
    data["ma_s"] = data["close"].rolling(short_w).mean()
    data["ma_l"] = data["close"].rolling(long_w).mean()
    data["signal"] = (data["ma_s"] > data["ma_l"]).astype(int)
    data["position"] = data["signal"].shift(1).fillna(0)
    data["strat_ret"] = data["position"] * data["ret"]
    equity = (1 + data["strat_ret"]).cumprod()
    return equity.iloc[-1] - 1

# 在训练集上扫描参数
best_ret = -999
best_params = (0, 0)
results = []

for s in range(5, 31, 5):
    for l in range(30, 81, 10):
        if s >= l:
            continue
        ret = test_strategy(train, s, l)
        results.append({"short": s, "long": l, "train_return": ret})
        if ret > best_ret:
            best_ret = ret
            best_params = (s, l)

print(f"训练集最优参数: MA{best_params[0]}/{best_params[1]}, 收益: {best_ret:+.2%}")

# 用最优参数在测试集上验证
test_ret = test_strategy(test, best_params[0], best_params[1])
print(f"测试集表现:     收益: {test_ret:+.2%}")

if test_ret < best_ret * 0.5:
    print("⚠️ 测试集表现远不如训练集，大概率过拟合")
elif test_ret < 0:
    print("🚨 测试集亏钱，策略不可靠")
else:
    print("✅ 测试集表现合理，参数可能有一定泛化能力")
```

如果训练集上年化 30% 但测试集上亏钱，你的"好策略"只是数据拟合。

## 陷阱 7：回测用前复权，但前复权是"会变的"

前复权价格会随着每次分红送转而重新计算。这意味着：你今天拉到的前复权数据和三个月前拉到的不一样——历史价格被修改了。

```python
from alphafeed import AlphaFeed

af = AlphaFeed()

# 同一只票，前复权 vs 不复权
df_fwd = af.klines.get("600519.SH", period="1d", count=500, adjust="forward", to_dataframe=True)
df_none = af.klines.get("600519.SH", period="1d", count=500, adjust="none", to_dataframe=True)

df_fwd = df_fwd.sort_values("trade_date").reset_index(drop=True)
df_none = df_none.sort_values("trade_date").reset_index(drop=True)

# 对比第一天的价格
print(f"前复权第一天收盘价: {df_fwd['close'].iloc[0]:.2f}")
print(f"不复权第一天收盘价: {df_none['close'].iloc[0]:.2f}")
print(f"差异: {df_fwd['close'].iloc[0] / df_none['close'].iloc[0] - 1:.2%}")
```

**实盘影响：** 如果你的策略在某个价位设了止损，但下次分红后前复权价格变了，那个止损位也变了。你回测时看到的"在 1500 元止损"，可能实盘中实际上是在 1480 元触发的。

**建议：** 回测时统一用一种复权方式，并在研究记录里注明。如果对绝对价格敏感（比如止损止盈），用不复权数据更真实。

## 完整的"去作弊"回测模板

把所有修正加在一起：

```python
import pandas as pd
import numpy as np
from alphafeed import AlphaFeed

af = AlphaFeed()

df = af.klines.get("600519.SH", period="1d", count=1000, adjust="forward", to_dataframe=True)
df = df.sort_values("trade_date").reset_index(drop=True)

# 策略信号
df["ma20"] = df["close"].rolling(20).mean()
df["ma60"] = df["close"].rolling(60).mean()
df["signal"] = (df["ma20"] > df["ma60"]).astype(int)

# 修正1：信号延迟一天
df["position"] = df["signal"].shift(1).fillna(0)

# 修正2：涨停日不能买入（用不复权检测）
df_raw = af.klines.get("600519.SH", period="1d", count=1000, adjust="none", to_dataframe=True)
df_raw = df_raw.sort_values("trade_date").reset_index(drop=True)
df_raw["raw_ret"] = df_raw["close"].pct_change()
df["can_buy"] = (df_raw["raw_ret"] < 0.095).astype(int)

# 如果昨天的信号是"买入"但今天涨停了，则无法执行
buy_signal = (df["position"] > df["position"].shift(1).fillna(0))
df.loc[buy_signal & (df["can_buy"] == 0), "position"] = 0

# 收益计算
df["ret"] = df["close"].pct_change().fillna(0)
df["trade"] = df["position"].diff().abs().fillna(0)

# 修正3：交易成本
cost_per_trade = 0.0015

# 修正4：滑点
slippage = 0.001

df["strategy_ret"] = df["position"] * df["ret"] - df["trade"] * (cost_per_trade + slippage)
df["equity"] = (1 + df["strategy_ret"]).cumprod()
df["buyhold"] = (1 + df["ret"]).cumprod()

# 结果
total_ret = df["equity"].iloc[-1] - 1
bh_ret = df["buyhold"].iloc[-1] - 1
peak = df["equity"].cummax()
max_dd = (df["equity"] / peak - 1).min()
sharpe = df["strategy_ret"].mean() / df["strategy_ret"].std() * np.sqrt(252) if df["strategy_ret"].std() > 0 else 0

print(f"=== 去作弊后的真实回测结果 ===")
print(f"策略收益: {total_ret:+.2%}")
print(f"买入持有: {bh_ret:+.2%}")
print(f"最大回撤: {max_dd:.2%}")
print(f"夏普比率: {sharpe:.2f}")
print(f"总交易成本: {(df['trade'] * (cost_per_trade + slippage)).sum():.2%}")
```

## 七个陷阱的影响排名

| 陷阱 | 对收益的影响 | 修正难度 |
| --- | --- | --- |
| 未来函数（用收盘价成交） | ⭐⭐⭐⭐⭐ 最大 | 简单（shift 一行） |
| 过拟合 | ⭐⭐⭐⭐⭐ 最大 | 中等（需要样本外测试） |
| 忽略交易成本 | ⭐⭐⭐⭐ 很大 | 简单（加一个扣减） |
| 忽略滑点 | ⭐⭐⭐ 中等 | 简单（用盘口估算） |
| 涨停买不到 | ⭐⭐ 看策略 | 中等 |
| 幸存者偏差 | ⭐⭐ 看股票池 | 较难 |
| 复权数据变化 | ⭐ 较小 | 注意即可 |

## 结语

回测赚钱不代表策略好，回测亏钱也不代表思路错。关键是你的回测有多"真实"。

每去掉一个作弊，回测收益都会缩水。这让人沮丧，但也在帮你：一个扣掉所有成本、修正所有偏差之后仍然盈利的策略，才值得你投入真金白银。

AlphaFeed 提供的数据在这里的作用是：让你可以同时拉前复权和不复权数据、用盘口数据估算滑点、用全市场行情避免幸存者偏差。数据维度越丰富，你的回测就越接近真实。

参考文献：
- Python SDK 快速开始：https://docs.alphafeed.org/zh-Hans/sdk/python-quickstart


回测年化 30%、夏普 2.5、最大回撤 8%。你兴奋地开了实盘，三个月后一看——亏了 12%。

你的策略回测很赚钱，实盘为什么亏？7 个陷阱逐个拆解

编程语言

大数据

职业发展

量化回测与实盘差距大？揭秘7大陷阱：收盘价成交、交易成本、滑点、幸存者偏差、涨停买不到、过拟合、复权数据变化。修正这些细节后，回测收益可能缩水20%-40%。用AlphaFeed数据实现更真实的策略测试，避免实盘亏损。

代码解释

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

你的策略回测很赚钱，实盘为什么亏？7 个陷阱逐个拆解-腾讯云开发者社区-腾讯云

你的策略回测很赚钱，实盘为什么亏？7 个陷阱逐个拆解

你的策略回测很赚钱，实盘为什么亏？7 个陷阱逐个拆解

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐