第 28 篇：回测里的偏差与成本

标的：今天成交额最大的 20 个永续合约；门槛：20 日成交额高于全样本中位数 13.8 百万美元
参数：在 20 组（新高 20–120 日 × 新低 10–60 日）里选年化最高的一组 = (40, 20)
2020-01-01 到 2026-08-31，年化 123.53%，最大回撤 -56.73%，期末是本金的 214 倍
平均同时持有 2.6 个，每年换手 57 次
按年： {2020: '221.6%', 2021: '701.9%', 2022: '-20.0%', 2023: '113.5%', 2024: '122.7%', 2025: '105.9%', 2026: '6.0%'} ——七年里 6 年赚钱

 再往后推几根     年化    最大回撤  持仓日上涨的比例
      0 1.2353 -0.5673    0.5368
      1 1.2452 -0.6548    0.5347
      2 1.1558 -0.6607    0.5386
三项体检全过：回撤不是 0，持仓日上涨的比例在五成出头，再往后推一根也只是温和地变差。
**第 27 篇的体检对这条曲线里的问题一个都查不出来**——它们查的是事件顺序，
而这条策略的事件顺序是对的。错的是数据本身，以及挑数据、挑参数的方式。

# 最常见的一种写法：把价格缩放到 0 和 1 之间。⚠️ 这两个最值要等最后一天才知道。
scaled = (price - price.min()) / (price.max() - price.min())
print(f"全样本归一化：最低 {price.min():,.0f}（{price.idxmin().date()}）、"
      f"最高 {price.max():,.0f}（{price.idxmax().date()}）；"
      f"2017 年最后一天的归一化值是 {scaled.loc['2017-12-31']:.3f}")

全样本归一化：最低 3,189（2017-09-14）、最高 124,659（2025-10-06）；2017 年最后一天的归一化值是 0.087

          归一化用的最值   在场比例     年化    最大回撤    期末倍数
全样本的最低价和最高价（偷看未来） 0.8035 0.4139 -0.8319 22.9441
  只用到今天为止的最低价和最高价 0.4988 0.2633 -0.7211  8.2825
         买入持有（对照） 1.0000 0.3793 -0.8319 18.3383
⚠️ 偷看版本「跑赢了买入持有」，老实版本跑输——而两者只差一件事：
   那个最高价是 2025 年才出现的，2017 年的你不可能拿它做归一化。

上过市的合约 864 个，最后一天还在交易 704 个，中途停止交易 160 个
            标的池  个数     年化    最大回撤    平均持仓
只用今天还在交易的 704 个 704 0.7801 -0.8984 24.4789
   全部上过市的 864 个 864 0.4434 -0.9368 30.3244
停止交易的合约在最后 60 天里：中位数 -39.2%，平均 -24.7%——**它们不是安静地消失，是先跌掉一半再消失**

228 组参数跑在 BTC 日线上：
  默认参数 (50, 200, 20, 3)（主线 v4）年化 21.53%，排第 77
  最好的一组 (20, 100, 40, 3) 年化 34.41%
  全部 228 组：中位数 19.06%，四分位 16.02%–23.04%，最差 3.83%，亏钱的组 0.0%

把 K 线打乱 100 次，每次重扫同样 228 组：
  打乱后「最好的一组」的年化：中位 20.09%，90% 区间 [9.78%, 35.56%]
  打乱后全部组的中位数：5.88%（真实数据是 19.06%）
  打乱之后「最好的一组」超过真实数据最好那组（34.41%）的比例：6.0%

样本内 2017-08-17～2023-08-26，样本外 2023-08-27～2026-08-31
                 这一组参数  样本内年化  样本外年化
样本内最优 (30, 100, 20, 3) 0.4004 0.1377
样本外最优 (20, 250, 60, 3) 0.2255 0.2574
   默认 (50, 200, 20, 3) 0.2569 0.0889
样本内最优的那一组，在样本外排第 47 / 228
样本内排名和样本外排名的秩相关 0.291——**不是 0，但也远不是 1**
样本内前 10 名在样本外的中位数 15.53%，全部 228 组在样本外的中位数 9.18%

         价格序列      年化    最大回撤  交易数    最差一笔
未复权（当时屏幕上的价格） -0.0370 -0.7456   33 -0.7018
       只按拆股复权  0.0957 -0.2795   37 -0.0826
 拆股 + 分红（全收益）  0.0982 -0.2785   37 -0.0814

2020-08-31 苹果四拆一，未复权的价格序列上那一天长这样：
              open    high     low   close
date                                      
2020-08-27  508.57  509.94  495.33  500.04
2020-08-28  504.05  505.77  498.31  499.23
2020-08-31  127.58  131.00  126.00  129.04
2020-09-01  132.76  134.80  130.53  134.18
回测看到的是「一天跌了 -74.15%」，而实际上股价一分钱没跌
分红：83 次，合计每股 40.13 美元；十年累计 只按拆股复权 1046.8%，全收益 1153.7%
⚠️ 加密没有拆股也没有分红，所以这一种偏差在加密上不存在——它是股票独有的

15% 的 ZigZag 在 BTC 日线上给出 85 个摆动点，其中低点 43 个
一个低点从**发生**到被**确认**：中位 9 天，平均 13.9 天，最长 52 天
确认那天的价格，已经比那个低点高了：中位 17.43%，平均 17.93%

          什么时候成交   在场比例     年化    最大回撤     期末是本金的几倍
   在摆动点当天成交（重绘版） 0.5912 6.1200 -0.1496 5.152677e+07
在摆动点被确认之后成交（老实版） 0.5787 0.3670 -0.6955 1.691330e+01
        买入持有（对照） 1.0000 0.3793 -0.8319 1.833830e+01

DAYS = ["2023-08-12",   # 这段时间里最平静的一天（周六，振幅 0.37%）
        "2023-07-19",   # 普通工作日
        "2023-10-23",   # 振幅最大的一天（20.4%，ETF 传闻）
        "2023-12-11",   # 普通工作日
        "2024-01-11",   # 现货 ETF 获批当天
        "2024-02-28",   # 振幅 13.3%，成交额 611 亿
        "2024-03-05",   # 冲上历史新高之后当天跌 6.7%，振幅 15.0%
        "2024-03-30"]   # 这套数据的最后一天（周六）

if __name__ == "__main__":
    paths = D.download_binance_book_ticker("BTCUSDT", DAYS)
    print(f"盘口 1 分钟汇总 {len(paths)} 天：")
    for path in paths:
        print(f"  {path}  {path.stat().st_size / 1024:.0f} KB")

8 天的公开盘口（价差的单位是基点，万分之一）：
                             平均价差    中位价差    最宽的一分钟  买一金额（万美元）      盘口更新    当天振幅
time                                                                            
2023-07-19 00:00:00+00:00  0.0339  0.0336    8.9892    38.6910  10613016  0.0145
2023-08-12 00:00:00+00:00  0.0340  0.0340    4.9033    64.9163   6497420  0.0037
2023-10-23 00:00:00+00:00  0.0565  0.0339  161.4750    19.6537  16873909  0.2039
2023-12-11 00:00:00+00:00  0.0414  0.0334   63.0863    16.4272  21887111  0.0823
2024-01-11 00:00:00+00:00  0.0316  0.0251   30.4765    10.6532  33466411  0.0735
2024-02-28 00:00:00+00:00  0.0312  0.0189  105.4453    26.5871  45403980  0.1326
2024-03-05 00:00:00+00:00  0.0465  0.0229   82.3285    16.3951  34588378  0.1499
2024-03-30 00:00:00+00:00  0.0158  0.0150    7.3764    31.9474   7398592  0.0116

全部 11,478 分钟：中位 0.0328 基点，平均 0.0364，95% 分位 0.0527，最宽的一分钟 7.47
最小变动价位 0.1 美元在平均价 46,749 上就是 0.0214 基点——**价差基本上就是一跳**
而永续合约的 taker 手续费是 5 基点，是中位价差的 153 倍

在**有真相**的市场上检验高低价价差估计量（单位：基点）：
                           真实中位价差    高低价估计       高估倍数
time                                                 
2023-07-19 00:00:00+00:00   0.034   85.574   2549.390
2023-08-12 00:00:00+00:00   0.034   14.030    412.576
2023-10-23 00:00:00+00:00   0.034 -185.307  -5464.086
2023-12-11 00:00:00+00:00   0.033 -124.179  -3713.018
2024-01-11 00:00:00+00:00   0.025   50.171   1995.273
2024-02-28 00:00:00+00:00   0.019 -656.283 -34728.480
2024-03-05 00:00:00+00:00   0.023  646.970  28246.625
2024-03-30 00:00:00+00:00   0.015   55.132   3664.371

同一段 320 天：估计值中位 68.37 基点，真实 0.0328 基点——**高估约 2087 倍**，而且 25.0% 的日子估出负数
  SPY      估计值中位   -3.98 基点，负数占 51.6%，日均振幅 0.88%
  AAPL     估计值中位    0.99 基点，负数占 49.7%，日均振幅 1.76%
  BTC 永续   估计值中位   67.20 基点，负数占 32.4%，日均振幅 3.76%
**一半的日子估出负数，说明它在这里就是噪声。** 有真相的市场用来检验方法，
没有真相的市场不要硬估——所以美股的价差这一篇不估，改做敏感性分析（片段 12）。

def us_fee_schedule() -> pd.Series:
    """现抓美股的两项监管费（第 28 篇）：SEC 的 Section 31 费和 FINRA 的 TAF。

    ⚠️ 两项都**只在卖出时收**。它们加起来通常只有成交金额的万分之几，
    真正贵的是买卖价差——而价差没有公开的历史数据。
    """
    links = re.findall(r'href="([^"]*fee-rate-advisories/\d{4}-\d)"',
                       _fetch(SEC_FEE_ADVISORIES, agent=REGULATOR_AGENT).decode())
    for link in links:                                  # 找最近一条 Section 31 的公告
        url = link if link.startswith("http") else "https://www.sec.gov" + link
        page = _fetch(url, agent=REGULATOR_AGENT).decode()
        if "Section 31 Transaction Fee Rate Advisory" in page:
            sec = parse_sec_fee_advisory(page)
            break
    else:
        raise ValueError("没找到 Section 31 的公告")
    finra = parse_finra_taf(_fetch(FINRA_FEE_RULES, agent=REGULATOR_AGENT).decode())
    return pd.concat([sec.rename(lambda k: f"SEC {k}"), finra.rename(lambda k: f"TAF {k}")])

SEC 财年                      2026
SEC 每百万美元                   20.6
SEC 占卖出金额               0.000021
SEC 生效日      2026-04-04 00:00:00
TAF 每股                  0.000166
TAF 每笔上限                     8.3

买入 500 股、200 美元一股（10 万美元），假设价差 1 个基点：
  买入：佣金 0.00，SEC 费 0.00，FINRA TAF 0.00，半个价差 5.00，合计 5.00，占名义价值 0.0050%
  卖出：佣金 0.00，SEC 费 2.06，FINRA TAF 0.08，半个价差 5.00，合计 7.14，占名义价值 0.0071%
⚠️ 两项监管费只在卖出时收，加起来 2.06 + 0.08 = 2.14 美元，不到万分之零点三；
   而 1 个基点的价差就是 5 美元。**零佣金不是没有成本，是把成本挪进了价差。**

    怎么成交   手续费   半个价差  滑点       合计  占名义价值
永续 maker  20.0 0.1638 0.0  20.1638 0.0002
永续 taker  50.0 0.1638 0.0  50.1638 0.0005
现货 taker 100.0 0.1638 0.0 100.1638 0.0010

主线策略在 BTC 现货上，单边成本 0.1002%（taker 手续费 + 半个价差）
 每年交易笔数   每年的成本
      2   0.40%
      6   1.20%
     12   2.40%
     52  10.42%
    250  50.08%
   1000 200.33%

同样的成本，折算成 R（第 23 篇：成本 ÷ 止损距离）：
 止损距离  一来一回占几个 R
 0.5%     0.4007
 2.0%     0.1002
 5.0%     0.0401
10.8%     0.0185
20.0%     0.0100

"""talab.costs：成本。第 28 篇。

第 27 篇的引擎里留了一个 `fee_rate`，这个模块负责把它算出来。

一笔交易的成本有四项，它们的可见度差别很大：

| 这一项 | 加密 | 美股 |
|---|---|---|
| **手续费** | 交易所公开费率表，精确 | 主流券商 0 佣金 |
| **监管费** | 没有 | SEC 的 Section 31 费 + FINRA 的 TAF，只在**卖出**时收，费率公开 |
| **买卖价差** | 公开的盘口数据可以量（第 28 篇量了 8 天） | **没有公开的历史报价**，量不了 |
| **滑点** | 用分钟线重放可以量（第 22 篇） | 日线上量不了 |

于是整篇的结论已经写在这张表里：**能精确算的那几项都很小，算不准的那几项才是大头。**
零佣金不是没有成本，它只是把成本从「看得见的佣金」挪到了「看不见的价差」。

所有函数都返回一个**拆开的**成本表，而不是一个总数——你要知道钱花在哪一项上，
才知道该换券商、换订单类型，还是干脆少交易。
"""
from __future__ import annotations

import numpy as np
import pandas as pd

# Binance 公开费率表里的 VIP 0 档（现货和 U 本位永续），单位是占成交名义价值的比例。
# ⚠️ 这是**今天**的费率：档位和优惠会变，拿它去算几年前的交易，算的是「按今天的费率会怎样」。
BINANCE_FEES = {"现货 taker": 0.0010, "现货 maker": 0.0010,
                "永续 taker": 0.0005, "永续 maker": 0.0002}

# 第 28 篇用 8 天的公开盘口量出来的 BTCUSDT 永续价差中位数，单位是基点（万分之一）。
BTC_PERP_SPREAD_BP = 0.033

def crypto(notional: float, venue: str = "永续 taker", spread_bp: float = BTC_PERP_SPREAD_BP,
           slippage_bp: float = 0.0) -> pd.Series:
    """加密交易所单边的成本拆解（做多的口径，买卖对称）。

    价差只算**一半**：报价的中间价才是「公允价」，你吃掉的是从中间价到卖一的那一半。
    """
    if venue not in BINANCE_FEES:
        raise ValueError(f"venue 只能是 {tuple(BINANCE_FEES)} 之一，收到 {venue!r}")
    fee = notional * BINANCE_FEES[venue]
    spread = notional * spread_bp / 2 / 10_000
    slippage = notional * slippage_bp / 10_000
    total = fee + spread + slippage
    return pd.Series({"名义价值": notional, "手续费": fee, "半个价差": spread, "滑点": slippage,
                      "合计": total, "占名义价值": total / notional})

def us_stock(price: float, shares: float, side: str = "buy", spread_bp: float = 1.0,
             sec_rate: float = 0.0, taf_per_share: float = 0.0, taf_cap: float = np.inf) -> pd.Series:
    """美股单边的成本拆解。费率用 `data.us_fee_schedule()` 现抓，别写死。

    ⚠️ **SEC 的 Section 31 费和 FINRA 的 TAF 只在卖出时收**，买入这两项都是 0。
    佣金按主流零佣金券商算成 0——但那不等于免费：券商把订单卖给做市商（订单流付费，PFOF），
    做市商的钱从价差里赚。所以 `spread_bp` 这一项才是美股真正的成本，而它**没有公开的历史数据**。
    """
    if side not in ("buy", "sell"):
        raise ValueError(f"side 只能是 buy 或 sell，收到 {side!r}")
    notional = price * shares
    commission = 0.0
    sec = notional * sec_rate if side == "sell" else 0.0
    taf = min(shares * taf_per_share, taf_cap) if side == "sell" else 0.0
    spread = notional * spread_bp / 2 / 10_000
    total = commission + sec + taf + spread
    return pd.Series({"名义价值": notional, "佣金": commission, "SEC 费": sec, "FINRA TAF": taf,
                      "半个价差": spread, "合计": total, "占名义价值": total / notional})

def cost_in_r(one_way: float, stop_distance: float) -> float:
    """把成本折算成 R 倍数（第 23 篇）：一来一回的成本 ÷ 止损距离。

    > 一笔交易的成本 = 2 × 单边成本 ÷ 止损距离（单位：R）

    这条式子说明**成本贵不贵取决于止损放得多远**：同样 0.1% 的来回成本，
    止损放 10% 时只占 0.01R，止损放 0.5% 时就占 0.2R——日内策略死在这里。
    """
    if stop_distance <= 0:
        raise ValueError("止损距离要大于 0")
    return 2 * one_way / stop_distance


def annual_drag(one_way: float, trades_per_year: float) -> float:
    """成本每年吃掉多少：`2 × 单边成本 × 每年交易笔数`（一笔进出算两次）。

    这是个近似（没算复利），但它足够回答那个最重要的问题：
    **你的策略一年要跑赢这个数，才刚够把成本挣回来。**
    """
    return 2 * one_way * trades_per_year


def frequency_table(one_way: float, trades_per_year=(2, 6, 12, 52, 250, 1000)) -> pd.DataFrame:
    """同样的单边成本，不同交易频率下每年被吃掉多少。

    成本和频率是**线性**关系，而策略的收益不是——这就是为什么高频信号在成本面前先死一次。
    """
    rows = [{"每年交易笔数": n, "每年的成本": annual_drag(one_way, n)} for n in trades_per_year]
    return pd.DataFrame(rows)

def corwin_schultz(high: pd.Series, low: pd.Series) -> pd.Series:
    """Corwin–Schultz (2012) 的高低价价差估计量：只用最高价和最低价估买卖价差。

    想法是：连续两根 K 线的**单根**高低幅里既有波动也有价差，**两根合起来**的高低幅里
    波动被放大而价差没有，两者相减就能把价差解出来。

    ⚠️ 第 28 篇在 BTC 上用真实盘口检验过它：**高估约两千倍，而且四分之一的日子估出负数**；
    在 SPY 和 AAPL 上一半的日子是负数。**它在这三个市场上都是噪声。**
    这个函数留在这里，是为了让你自己能重做那次检验——
    **有真相的市场用来检验方法，没有真相的市场不要硬估。**
    """
    beta = (np.log(high / low) ** 2).rolling(2).sum()
    high2 = pd.concat([high, high.shift(1)], axis=1).max(axis=1)
    low2 = pd.concat([low, low.shift(1)], axis=1).min(axis=1)
    gamma = np.log(high2 / low2) ** 2
    k = 3 - 2 * np.sqrt(2)
    alpha = (np.sqrt(2 * beta) - np.sqrt(beta)) / k - np.sqrt(gamma / k)
    return (2 * (np.exp(alpha) - 1) / (1 + np.exp(alpha))).rename("价差估计")

def download_binance_book_ticker(symbol: str, days, market: str = "um",
                                dest: str = "data/binance") -> list[Path]:
    """下载最优买卖报价（第 28 篇），**下载完立刻聚合成 1 分钟，再把原始文件删掉**。

    原始文件一天 70–300 MB、几百万到几千万行（盘口每变一次就写一行）。留着它没有意义：
    这一篇要回答的是「价差有多宽、买一卖一有多厚」，1 分钟的汇总（一天 1,440 行）就够了。
    想重算别的统计量，重新下载就是了——这里保存的是**结论的原料**，不是原始数据的副本。

    ⚠️ 这套数据只有 **2023-05-16 到 2024-03-30**（320 天）。之前和之后 Binance 都没有公开，
    所以这一篇量到的价差是这 11 个月的事实，不能直接外推到 2017 年或 2026 年。
    """
    folder = Path(dest) / market / symbol / "bookTicker-1m"
    folder.mkdir(parents=True, exist_ok=True)
    paths = []
    for day in days:
        target = folder / f"{symbol}-bookTicker-1m-{day}.csv.gz"
        if not target.exists():
            name = f"{symbol}-bookTicker-{day}.zip"
            url = f"{BINANCE_BASE}/futures/{market}/daily/bookTicker/{quote(symbol)}/{quote(name)}"
            try:
                raw = _fetch(url)
            except urllib.error.HTTPError as e:
                if e.code == 404:                   # 这一天没有公开数据
                    continue
                raise
            with zipfile.ZipFile(io.BytesIO(raw)) as z:
                frame = pd.read_csv(z.open(z.namelist()[0]),
                                    usecols=["best_bid_price", "best_bid_qty", "best_ask_price",
                                             "best_ask_qty", "transaction_time"])
            mid = (frame["best_bid_price"] + frame["best_ask_price"]) / 2
            frame["价差"] = (frame["best_ask_price"] - frame["best_bid_price"]) / mid * 10_000
            frame["中间价"] = mid
            frame["time"] = pd.to_datetime(frame["transaction_time"], unit="ms", utc=True).dt.floor("min")
            minute = frame.groupby("time").agg(
                更新次数=("价差", "size"), 价差=("价差", "mean"), 最宽价差=("价差", "max"),
                买一量=("best_bid_qty", "mean"), 卖一量=("best_ask_qty", "mean"),
                中间价=("中间价", "mean"))
            minute.to_csv(target)
        paths.append(target)
    return paths

def test_corwin_schultz_is_exact_when_there_is_no_volatility():
    """价格不动、只有一个固定的价差时，这个估计量应该精确地把价差还原出来。"""
    for spread in [0.001, 0.005, 0.02]:
        price = pd.Series([100.0] * 10)
        high, low = price * (1 + spread / 2), price * (1 - spread / 2)
        estimate = C.corwin_schultz(high, low).dropna()
        assert estimate.to_numpy() == pytest.approx(spread, rel=1e-9)

def test_corwin_schultz_falls_apart_when_volatility_dominates():
    """真实市场上波动远大于价差，估计量会满地负数——第 28 篇量到 SPY 有一半的日子是负的。"""
    rng = np.random.default_rng(28)
    close = pd.Series(100 * np.exp(np.cumsum(rng.standard_normal(2_000) * 0.02)))
    noise = np.abs(rng.standard_normal(2_000)) * 0.02
    estimate = C.corwin_schultz(close * (1 + noise), close * (1 - noise)).dropna()
    assert (estimate < 0).mean() > 0.2                      # 大量负数＝它在这里是噪声

def test_us_regulatory_fees_are_charged_on_sales_only():
    """SEC 费和 TAF 只在卖出时收，买入这两项都是 0。"""
    kwargs = dict(price=200.0, shares=500.0, spread_bp=1.0, sec_rate=20.6e-6,
                  taf_per_share=0.000166, taf_cap=8.30)
    buy, sell = C.us_stock(side="buy", **kwargs), C.us_stock(side="sell", **kwargs)
    assert buy["SEC 费"] == 0.0 and buy["FINRA TAF"] == 0.0
    assert sell["SEC 费"] == pytest.approx(100_000 * 20.6e-6)
    assert sell["FINRA TAF"] == pytest.approx(500 * 0.000166)
    assert buy["半个价差"] == sell["半个价差"] == pytest.approx(100_000 * 1.0 / 2 / 10_000)
    assert sell["合计"] > buy["合计"]
    with pytest.raises(ValueError):
        C.us_stock(200.0, 500.0, side="随便")

def test_cost_in_r_depends_on_where_the_stop_is():
    """同样 0.05% 的单边成本，止损放 10% 只占 0.01R，放 0.5% 就占 0.2R。"""
    assert C.cost_in_r(0.0005, 0.10) == pytest.approx(0.01)
    assert C.cost_in_r(0.0005, 0.005) == pytest.approx(0.20)
    with pytest.raises(ValueError):
        C.cost_in_r(0.0005, 0.0)

def test_parse_sec_fee_advisory():
    out = D.parse_sec_fee_advisory(SEC_PAGE)
    assert out["财年"] == 2026
    assert out["每百万美元"] == pytest.approx(20.60)
    assert out["占卖出金额"] == pytest.approx(20.60 / 1e6)
    assert out["生效日"] == pd.Timestamp("2026-04-04")
    with pytest.raises(ValueError):
        D.parse_sec_fee_advisory("<p>今天天气不错</p>")


def test_parse_finra_taf():
    out = D.parse_finra_taf(FINRA_PAGE)
    assert out["每股"] == pytest.approx(0.000166)
    assert out["每笔上限"] == pytest.approx(8.30)
    with pytest.raises(ValueError):
        D.parse_finra_taf("<p>今天天气也不错</p>")

277 passed in 0.91s

245 passed, 32 skipped in 1.01s

                    修到哪一步      年化    最大回撤   平均持仓     每年换手 赚钱的年份  比上一步掉了
                原样：四个问题都在  1.2353 -0.5673 2.5511  57.2608   6/7     NaN
① 不挑参数，固定 60 日新高 / 20 日新低  1.0765 -0.6778 1.9979  44.8193   5/7  0.1588
            ② 门槛改成当时算得出来的  1.0576 -0.6778 1.9729  44.5195   5/7  0.0189
      ③ 名单改成当时成交额最大的 20 个 -0.2441 -0.9975 5.9667 226.1951   3/7  1.3017
                   ④ 加上成本 -0.2603 -0.9978 5.9667 226.1951   3/7  0.0162

  标的              成本   单边费率     年化    最大回撤  交易数      手续费合计
 SPY            不算成本 0.0000 0.0297 -0.1235   39     0.0000
 SPY  监管费 + 1 个基点的价差 0.0001 0.0291 -0.1242   39   642.2658
 SPY      价差按 5 个基点算 0.0003 0.0275 -0.1263   39  2435.9111
AAPL            不算成本 0.0000 0.0989 -0.2785   37     0.0000
AAPL  监管费 + 1 个基点的价差 0.0001 0.0983 -0.2796   37  1009.8519
AAPL      价差按 5 个基点算 0.0003 0.0967 -0.2828   37  3818.8418
 BTC            不算成本 0.0000 0.2160 -0.3232   30     0.0000
 BTC 现货 taker + 半个价差 0.0010 0.2094 -0.3320   30 21137.4390
 BTC 再加第 22 篇量到的止损滑点 0.0015 0.2063 -0.3362   30 30925.8513