第 23 篇：止损、止盈与出场

买入日 2020-10-10，开盘价买入 11050.64
初始止损 10126.43，一个 R = 924.21（占进场价 8.36%）
  +1R = 11974.85
  +2R = 12899.06
  +3R = 13823.26

                               open      high       low     close  浮盈 R
time                                                                   
2020-10-10 00:00:00+00:00  11050.64  11491.00  11050.51  11293.22  0.26
2020-10-11 00:00:00+00:00  11293.22  11445.00  11221.00  11369.02  0.34
2020-10-12 00:00:00+00:00  11369.02  11720.01  11172.00  11528.25  0.52
2020-10-13 00:00:00+00:00  11528.24  11557.00  11300.00  11420.56  0.40
2020-10-14 00:00:00+00:00  11420.57  11547.98  11280.00  11417.89  0.40
2020-10-15 00:00:00+00:00  11417.89  11617.34  11250.83  11505.12  0.49
2020-10-16 00:00:00+00:00  11505.13  11541.15  11200.00  11319.32  0.29
2020-10-17 00:00:00+00:00  11319.24  11402.42  11255.00  11360.20  0.33
2020-10-18 00:00:00+00:00  11360.31  11505.00  11346.22  11503.14  0.49
2020-10-19 00:00:00+00:00  11503.14  11823.99  11407.96  11751.47  0.76
2020-10-20 00:00:00+00:00  11751.46  12038.38  11677.59  11909.99  0.93
2020-10-21 00:00:00+00:00  11910.00  13217.68  11886.95  12780.96  1.87
2020-10-22 00:00:00+00:00  12780.75  13185.00  12678.08  12968.52  2.08

一个 R = 进场价 − 初始止损价 = 11050.64 − 10126.43 = 924.21
  决策点收盘   12968.52 → +2.08 R
  最后出场    34051.24 → +24.89 R
  刚好打到止损  10126.43 → -1.00 R

换成别的标的也一样：SPY 2023-11-08 那一笔
  进场 437.55，止损 421.57，一个 R = 15.98 美元（3.65%）；出场 510.85 → +4.59 R
  两笔交易的止损距离差 58 倍，换成 R 之后才能放在一起比：BTC 那笔 24.9 R，SPY 这笔 4.6 R

METHODS = {"结构：前 20 根低点再往下 0.5 ATR": K.Exit(stop="structure", lookback=20, buffer=0.5),
           "波动率：进场价往下 3 ATR": K.Exit(stop="atr", k=3.0),
           "固定比例：进场价往下 10%": K.Exit(stop="percent", percent=0.10)}
rows = []
for name, (df, _) in MARKETS.items():
    signal = entries(df).to_numpy()
    where = np.flatnonzero(signal[:-1]) + 1                     # 信号的下一根，就是进场的那一根
    where = where[where > 200]
    opens = df["open"].to_numpy()[where]
    atr = I.atr(df["high"], df["low"], df["close"]).to_numpy()   # 算一次，别在循环里反复算
    distances = {label: 1 - np.array([K.initial_stop(df, i, price, plan, atr)
                                      for i, price in zip(where, opens)]) / opens
                 for label, plan in METHODS.items()}
    for label, distance in distances.items():
        rows.append({"标的": name, "初始止损": label, "进场点": len(where), "距离中位数": np.median(distance),
                     "最近": distance.min(), "最远": distance.max(),
                     "比 3 ATR 远的比例": np.mean(distance > distances["波动率：进场价往下 3 ATR"])})
print(pd.DataFrame(rows).round(3).to_string(index=False))

      标的                   初始止损  进场点  距离中位数    最近    最远  比 3 ATR 远的比例
  SPY 日线 结构：前 20 根低点再往下 0.5 ATR  458  0.053 0.013 0.124         0.996
  SPY 日线        波动率：进场价往下 3 ATR  458  0.027 0.011 0.061         0.000
  SPY 日线         固定比例：进场价往下 10%  458  0.100 0.100 0.100         1.000
 AAPL 日线 结构：前 20 根低点再往下 0.5 ATR  385  0.110 0.047 0.289         0.982
 AAPL 日线        波动率：进场价往下 3 ATR  385  0.056 0.036 0.143         0.000
 AAPL 日线         固定比例：进场价往下 10%  385  0.100 0.100 0.100         0.984
  BTC 日线 结构：前 20 根低点再往下 0.5 ATR  225  0.216 0.076 0.495         0.987
  BTC 日线        波动率：进场价往下 3 ATR  225  0.113 0.061 0.262         0.000
  BTC 日线         固定比例：进场价往下 10%  225  0.100 0.100 0.100         0.356
BTC 4 小时 结构：前 20 根低点再往下 0.5 ATR 1360  0.081 0.018 0.359         0.968
BTC 4 小时        波动率：进场价往下 3 ATR 1360  0.048 0.018 0.228         0.000
BTC 4 小时         固定比例：进场价往下 10% 1360  0.100 0.100 0.100         0.949
BTC 1 小时 结构：前 20 根低点再往下 0.5 ATR 4735  0.039 0.003 0.224         0.942
BTC 1 小时        波动率：进场价往下 3 ATR 4735  0.024 0.004 0.135         0.000
BTC 1 小时         固定比例：进场价往下 10% 4735  0.100 0.100 0.100         0.996

同一套入场信号，只换初始止损（跟踪、目标、时间都不设，出场信号仍是死叉）：
      标的                   初始止损  交易数  被止损出场  每笔期望 R    合计 R
  SPY 日线 结构：前 20 根低点再往下 0.5 ATR    5  0.200   2.312  11.560
  SPY 日线        波动率：进场价往下 3 ATR    7  0.429   2.831  19.817
  SPY 日线         固定比例：进场价往下 10%    5  0.200   1.559   7.796
 AAPL 日线 结构：前 20 根低点再往下 0.5 ATR    5  0.200   3.681  18.406
 AAPL 日线        波动率：进场价往下 3 ATR    5  0.200   6.579  32.893
 AAPL 日线         固定比例：进场价往下 10%    5  0.200   4.831  24.154
  BTC 日线 结构：前 20 根低点再往下 0.5 ATR    9  0.222   2.014  18.123
  BTC 日线        波动率：进场价往下 3 ATR   10  0.400   2.782  27.825
  BTC 日线         固定比例：进场价往下 10%   10  0.500   3.691  36.914
BTC 4 小时 结构：前 20 根低点再往下 0.5 ATR   57  0.351   3.315 188.951
BTC 4 小时        波动率：进场价往下 3 ATR   62  0.468   3.704 229.646
BTC 4 小时         固定比例：进场价往下 10%   53  0.226   1.315  69.685
BTC 1 小时 结构：前 20 根低点再往下 0.5 ATR  263  0.433   0.778 204.510
BTC 1 小时        波动率：进场价往下 3 ATR  301  0.555   0.887 266.942
BTC 1 小时         固定比例：进场价往下 10%  225  0.044   0.182  40.953

跟踪止损注定要还回去一部分：按最大浮盈分组，最后留住了多少
  最大浮盈 [0, 1) R： 676 笔，最终 R 中位数  -0.59，（浮盈没到 1R，谈不上留住多少）
  最大浮盈 [1, 2) R： 212 笔，最终 R 中位数   0.21，留住比例中位数 0.17
  最大浮盈 [2, 3) R：  87 笔，最终 R 中位数   1.16，留住比例中位数 0.47
  最大浮盈 [3, 5) R：  81 笔，最终 R 中位数   2.21，留住比例中位数 0.61
  最大浮盈 [5, 1000) R：  63 笔，最终 R 中位数   4.59，留住比例中位数 0.69

def race(target, stop=1.0, paths=10000, step=0.05, chunk=1000, seed=23):
    """无漂移随机游走：每步等概率走 ±step 个 R，先碰到 +target 记 target，先碰到 −stop 记 −stop。"""
    rng = np.random.default_rng(seed)
    out, level, alive = np.zeros(paths), np.zeros(paths), np.ones(paths, bool)
    while alive.any():
        idx = np.flatnonzero(alive)
        walk = level[idx, None] + np.cumsum(rng.choice([-step, step], (len(idx), chunk)), axis=1)
        up, down = walk >= target, walk <= -stop
        first_up = np.where(up.any(1), up.argmax(1), chunk)
        first_down = np.where(down.any(1), down.argmax(1), chunk)
        done = np.minimum(first_up, first_down) < chunk
        out[idx[done]] = np.where(first_up < first_down, target, -stop)[done]
        level[idx], alive[idx] = walk[:, -1], ~done
    return out


rows = []
for target in [0.5, 1, 2, 3, 5, 10]:
    r = race(target)
    win = (r > 0).mean()
    rows.append({"目标": f"{target}R", "实测胜率": win, "理论胜率 = 1 ÷ (1 + 目标)": 1 / (1 + target),
                 "盈亏比": target, "胜率 × 盈亏比": win * target, "败率 × 1": 1 - win, "平均 R": r.mean()})
print(pd.DataFrame(rows).round(4).to_string(index=False))

  目标   实测胜率  理论胜率 = 1 ÷ (1 + 目标)  盈亏比  胜率 × 盈亏比  败率 × 1    平均 R
0.5R 0.6515               0.6667  0.5    0.3258  0.3485 -0.0228
  1R 0.5005               0.5000  1.0    0.5005  0.4995  0.0010
  2R 0.3361               0.3333  2.0    0.6722  0.6639  0.0083
  3R 0.2516               0.2500  3.0    0.7548  0.7484  0.0064
  5R 0.1694               0.1667  5.0    0.8470  0.8306  0.0164
 10R 0.0932               0.0909 10.0    0.9320  0.9068  0.0252

TARGETS = [0.5, 1, 1.5, 2, 3, 4, 6, 8, 10]
COST = 0.001                                                    # 一来一回 0.1%，第 29 篇才认真算成本
scans = {}
rng = np.random.default_rng(23)
for name in ["SPY 日线", "BTC 日线", "BTC 4 小时", "BTC 1 小时"]:
    df = MARKETS[name][0]
    shuffled = [shuffle_bars(df, rng) for _ in range(5)]
    rows = []
    for target in TARGETS:
        plan = K.Exit(stop="atr", k=3.0, trail="none", target_r=target)
        t = K.run(df, entries(df), plan)
        score = K.expectancy(t["R 倍数"])
        cost = (COST / (t["R"] / t["买入价"])).sum()             # 每笔的成本折算成几个 R，再加起来
        fake = [K.expectancy(K.run(s, entries(s), plan)["R 倍数"]) for s in shuffled]
        rows.append({"目标": f"{target}R", "交易数": int(score["交易数"]), "胜率": score["胜率"],
                     "平均盈利": score["平均盈利"], "平均亏损": score["平均亏损"],
                     "打平需要的胜率": score["平均亏损"] / (score["平均亏损"] + score["平均盈利"]),
                     "每笔期望 R": score["期望值"], "合计 R": t["R 倍数"].sum(), "成本合计 R": cost,
                     "扣成本后合计 R": t["R 倍数"].sum() - cost,
                     "打乱后的胜率": np.mean([f["胜率"] for f in fake]),
                     "打乱后的每笔期望 R": np.mean([f["期望值"] for f in fake])})
    scans[name] = pd.DataFrame(rows)
    print(f"\n--- {name} ---")
    print(scans[name].round(3).to_string(index=False))

--- BTC 4 小时 ---
  目标  交易数    胜率   平均盈利  平均亏损  打平需要的胜率  每笔期望 R    合计 R  成本合计 R  扣成本后合计 R  打乱后的胜率  打乱后的每笔期望 R
0.5R  448 0.710  0.726 1.196    0.622   0.168  75.426   9.931    65.496   0.658       0.061
  1R  293 0.601  1.248 1.204    0.491   0.269  78.882   6.527    72.355   0.542       0.106
1.5R  208 0.543  1.790 1.210    0.403   0.420  87.327   4.662    82.664   0.463       0.152
  2R  165 0.491  2.291 1.192    0.342   0.518  85.515   3.511    82.004   0.410       0.188
  3R  123 0.431  3.314 1.204    0.267   0.743  91.328   2.614    88.713   0.344       0.317
  4R   95 0.389  4.348 1.246    0.223   0.933  88.625   2.113    86.512   0.295       0.379
  6R   89 0.326  6.258 1.208    0.162   1.225 109.032   1.844   107.188   0.243       0.558
  8R   66 0.303  8.369 1.220    0.127   1.686 111.244   1.372   109.872   0.210       0.700
 10R   60 0.250 10.133 1.288    0.113   1.567  94.039   1.289    92.750   0.182       0.798

      标的   目标  交易数  止损距离中位数  每笔成本折合    合计 R  成本合计 R  成本吃掉
  SPY 日线 0.5R  110    0.028   0.038  18.213   4.152 0.228
  SPY 日线   2R   35    0.030   0.036  25.914   1.273 0.049
  SPY 日线  10R    6    0.030   0.034  22.669   0.205 0.009
  BTC 日线 0.5R   85    0.116   0.009  14.965   0.744 0.050
  BTC 日线   2R   29    0.134   0.008  18.375   0.238 0.013
  BTC 日线  10R   14    0.140   0.008  30.684   0.108 0.004
BTC 1 小时 0.5R 1443    0.024   0.046 108.577  66.444 0.612
BTC 1 小时   2R  554    0.025   0.045 124.086  25.116 0.202
BTC 1 小时  10R  193    0.027   0.041  86.678   7.918 0.091

for name in ["SPY 日线", "BTC 日线", "BTC 4 小时"]:
    df = MARKETS[name][0]
    rows = []
    for bars in [5, 10, 20, 40, 60, 100, None]:
        t = K.run(df, entries(df), K.Exit(stop="atr", k=3.0, trail="none", max_bars=bars), exits=deaths(df))
        score = K.expectancy(t["R 倍数"])
        rows.append({"最多拿": "不限" if bars is None else f"{bars} 根", "交易数": int(score["交易数"]),
                     "胜率": score["胜率"], "盈亏比": score["盈亏比"], "每笔期望 R": score["期望值"],
                     "合计 R": t["R 倍数"].sum(), "在场时间": t["根数"].sum() / len(df),
                     "被时间赶出来的": (t["原因"] == "时间到").mean()})
    print(f"\n--- {name} ---")
    print(pd.DataFrame(rows).round(3).to_string(index=False))

--- BTC 4 小时 ---
  最多拿  交易数    胜率    盈亏比  每笔期望 R    合计 R  在场时间  被时间赶出来的
  5 根  526 0.504  1.601   0.124  65.090 0.130    0.937
 10 根  390 0.538  1.593   0.209  81.409 0.185    0.859
 20 根  294 0.524  1.857   0.339  99.575 0.259    0.762
 40 根  203 0.537  2.069   0.562 114.107 0.311    0.616
 60 根  163 0.528  2.385   0.743 121.078 0.349    0.546
100 根  131 0.435  3.752   1.032 135.221 0.388    0.427
   不限   62 0.387 10.890   3.704 229.646 0.457    0.000

sample = pd.concat(distributions["C 3 ATR 吊灯跟踪"], ignore_index=True)
score = K.expectancy(sample)
print(score.round(3).to_string())
print(f"\n把公式拆开算一遍：{score['胜率']:.4f} × {score['平均盈利']:.4f} − "
      f"{1 - score['胜率']:.4f} × {score['平均亏损']:.4f} = {score['期望值']:.4f}")
print(f"直接对这 {len(sample)} 个 R 取平均：{sample.mean():.4f}（两者相等，期望值就是平均 R）")
print(f"中位数却是 {sample.median():.3f}：一半以上的交易在亏钱，靠的是右边那条尾巴")
print(f"打平需要的胜率 = 平均亏损 ÷（平均亏损 + 平均盈利）= "
      f"{score['平均亏损']:.3f} ÷ ({score['平均亏损']:.3f} + {score['平均盈利']:.3f}) = "
      f"{score['平均亏损'] / (score['平均亏损'] + score['平均盈利']):.1%}，实测胜率 {score['胜率']:.1%}")

交易数      1119.000
胜率          0.399
平均盈利        1.641
平均亏损        0.647
盈亏比         2.535
期望值         0.265
中位数        -0.233
最好的一笔      24.887
最差的一笔      -3.218

把公式拆开算一遍：0.3986 × 1.6408 − 0.6014 × 0.6471 = 0.2648
直接对这 1119 个 R 取平均：0.2648（两者相等，期望值就是平均 R）
中位数却是 -0.233：一半以上的交易在亏钱，靠的是右边那条尾巴
打平需要的胜率 = 平均亏损 ÷（平均亏损 + 平均盈利）= 0.647 ÷ (0.647 + 1.641) = 28.3%，实测胜率 39.9%

def r_multiple(entry_price: float, stop_price: float, exit_price: float) -> float:
    """这笔交易赚了（亏了）几个 R。

    R = 进场价 − 初始止损价，是开仓那一刻就定下来的、你打算认输的距离。
    严格按初始止损算：止损后来上移了多少，不改变这笔交易当初冒的风险。
    """
    risk = entry_price - stop_price
    if risk <= 0:
        raise ValueError(f"止损价要在进场价下方（进场 {entry_price}，止损 {stop_price}）")
    return (exit_price - entry_price) / risk

@dataclass
class Exit:
    """一套出场方案：四个问题各一个答案。"""
    stop: str = "atr"                 # 一、初始止损：atr / structure / percent
    k: float = 3.0                    #     atr：进场价往下几个 ATR
    lookback: int = 20                #     structure：往前看几根找最低点
    buffer: float = 0.5               #     structure：在那个最低点再往下几个 ATR
    percent: float = 0.10             #     percent：进场价往下百分之几
    trail: str = "none"               # 二、止损要不要跟着走
    trail_k: float = 3.0              #     chandelier：最高价往下几个 ATR
    trail_bars: int = 20              #     low：跟着前几根的最低点走
    trail_r: float = 1.0              #     breakeven：浮盈几个 R 之后把止损提到成本价
    target_r: float | None = None     # 三、目标价：赚到几个 R 就收（None = 不设目标）
    partial_r: float | None = None    #     浮盈几个 R 时先平掉一部分（None = 不分批）
    partial_fraction: float = 0.5     #     分批平掉多少
    max_bars: int | None = None       # 四、最多拿几根 K 线（None = 不限）
    trigger: str = "close"            # 止损和目标用收盘价触发，还是用盘中最高最低价
    atr_period: int = 14

    def __post_init__(self):
        for name, value, allowed in [("stop", self.stop, STOPS), ("trail", self.trail, TRAILS),
                                     ("trigger", self.trigger, TRIGGERS)]:
            if value not in allowed:
                raise ValueError(f"{name} 只能是 {allowed} 之一，收到 {value!r}")
        if not 0 < self.partial_fraction < 1:
            raise ValueError("partial_fraction 要在 0 和 1 之间")
        if self.partial_r is not None and self.target_r is not None and self.partial_r >= self.target_r:
            raise ValueError("分批止盈的位置要在最终目标下方，否则它永远轮不到")

    def describe(self) -> pd.Series:
        """把四个答案列出来，用来检查「这套出场真的想全了吗」。"""
        first = {"atr": f"进场价下方 {self.k} 倍 ATR",
                 "structure": f"前 {self.lookback} 根的最低点再往下 {self.buffer} 倍 ATR",
                 "percent": f"进场价下方 {self.percent:.0%}"}[self.stop]
        second = {"none": "不动，一直用初始止损",
                  "chandelier": f"吊灯：最高价往下 {self.trail_k} 倍 ATR，只上移",
                  "low": f"跟着前 {self.trail_bars} 根的最低点走，只上移",
                  "breakeven": f"浮盈 {self.trail_r} 个 R 之后提到成本价，再不动"}[self.trail]
        third = "不设目标，让它自己走完" if self.target_r is None else f"赚到 {self.target_r} 个 R 就全部离场"
        if self.partial_r is not None:
            third += f"；浮盈 {self.partial_r} 个 R 时先平 {self.partial_fraction:.0%}"
        fourth = "不限" if self.max_bars is None else f"最多 {self.max_bars} 根 K 线"
        return pd.Series({"一、初始止损": first, "二、止损跟不跟": second,
                          "三、目标价": third, "四、最多拿多久": fourth})

def initial_stop(df: pd.DataFrame, i: int, entry_price: float, plan: Exit,
                 atr: np.ndarray | None = None) -> float:
    """第 i 根 K 线上按 `plan` 算初始止损价。

    只用第 i−1 根及之前的数据：ATR 取前一根的值，结构低点取前 `lookback` 根的最低价，
    都不含第 i 根自己——第 i 根的最低价要等收盘才知道，进场那一刻还没有。
    """
    if plan.stop == "percent":
        return entry_price * (1 - plan.percent)
    if atr is None:
        from talab import indicators as I
        atr = I.atr(df["high"], df["low"], df["close"], plan.atr_period).to_numpy()
    if plan.stop == "atr":
        return entry_price - plan.k * atr[i - 1]
    low = df["low"].to_numpy(float)[max(0, i - plan.lookback):i].min()
    return low - plan.buffer * atr[i - 1]

def run(df: pd.DataFrame, entries: pd.Series, plan: Exit | None = None,
        exits: pd.Series | None = None) -> pd.DataFrame:
    """按一套出场方案跑一遍历史，每笔交易一行。

    `exits` 是策略自己的出场信号（比如主线策略的死叉），它和 `plan` 里的四个答案并存：
    谁先到就听谁的，出场信号排在最前面判断。不给 `exits` 就只靠止损、目标和时间出场。

    约定和第 21 篇一致：信号在收盘时成立，下一根开盘市价成交；持仓期间不接新信号。
    进场的那一根也可能就把你打掉——买在开盘价，这根 K 线剩下的时间照样会走。

    止损和目标同时在一根 K 线里被碰到时（只有 `trigger="extreme"` 才可能发生），
    按**止损**算，并在「原因」里记成「同一根」——K 线看不出谁先到（第 22 篇），
    这里选保守的那一边，并且把它数出来，而不是假装没发生。

    返回的表里，「R 倍数」是这笔交易的最终成绩；分批止盈时它是两段的加权平均。
    「最大浮盈」和「最大浮亏」是持仓期间盘中到过的最好和最差的浮动盈亏（MFE 和 MAE），
    它们回答「这笔交易有没有给过你机会」和「你离被打掉有多近」。进场那一根按整根的
    最高最低价算，所以最大浮亏可能比你实际经历的更难看一点。
    """
    plan = plan or Exit()
    from talab import indicators as I
    atr = I.atr(df["high"], df["low"], df["close"], plan.atr_period).to_numpy()
    o, h, l, c = (df[x].to_numpy(float) for x in ["open", "high", "low", "close"])
    signal = entries.reindex(df.index).fillna(False).to_numpy(bool)
    leave = (np.zeros(len(c), bool) if exits is None
             else exits.reindex(df.index).fillna(False).to_numpy(bool))
    rows, holding = [], False
    entry_price = entry_i = risk = highest = best = worst = done = left = np.nan
    start = int(np.argmax(~np.isnan(atr))) + 2
    for i in range(start, len(c)):
        if not holding and signal[i - 1]:                             # 昨天收盘的信号，今天开盘成交
            price = o[i]
            level = initial_stop(df, i, price, plan, atr)
            if level < price:                                         # 止损要在进场价下方，否则这笔跳过
                holding, entry_price, entry_i, risk = True, price, i, price - level
                stop_price, highest, done, left, best, worst = level, price, 0.0, 1.0, 0.0, 0.0
        if not holding:
            continue
        if plan.trail == "chandelier":
            stop_price = max(stop_price, highest - plan.trail_k * atr[i - 1])
        elif plan.trail == "low":
            stop_price = max(stop_price, l[max(0, i - plan.trail_bars):i].min())
        elif plan.trail == "breakeven" and highest >= entry_price + plan.trail_r * risk:
            stop_price = max(stop_price, entry_price)
        best = max(best, (h[i] - entry_price) / risk)
        worst = min(worst, (l[i] - entry_price) / risk)
        target = entry_price + plan.target_r * risk if plan.target_r is not None else np.inf
        price = reason = None
        if leave[i - 1] and i > entry_i:                               # 昨天收盘的出场信号，今天开盘执行
            price, reason = o[i], "出场信号"
        elif plan.trigger == "close":
            if c[i] <= stop_price:
                price, reason = c[i], "止损"
            elif c[i] >= target:
                price, reason = c[i], "止盈"
        else:
            hit_stop, hit_target = l[i] <= stop_price, h[i] >= target
            if hit_stop and hit_target:
                price, reason = (o[i] if o[i] <= stop_price else stop_price), "同一根"
            elif hit_stop:
                price, reason = (o[i] if o[i] <= stop_price else stop_price), "止损"
            elif hit_target:
                price, reason = (o[i] if o[i] >= target else target), "止盈"
        if reason is None and plan.max_bars is not None and i - entry_i >= plan.max_bars:
            price, reason = c[i], "时间到"
        if reason is None and i == len(c) - 1:
            price, reason = c[i], "未平仓"
        if reason is None and left == 1.0 and plan.partial_r is not None:   # 先平一部分，剩下的接着走
            level = entry_price + plan.partial_r * risk
            got = c[i] if plan.trigger == "close" and c[i] >= level else (max(o[i], level) if plan.trigger == "extreme" and h[i] >= level else None)
            if got is not None:
                done, left = plan.partial_fraction * (got - entry_price) / risk, 1 - plan.partial_fraction
        highest = max(highest, h[i])
        if reason is None:
            continue
        rows.append({"买入日": df.index[entry_i], "买入价": entry_price, "初始止损": entry_price - risk,
                     "R": risk, "卖出日": df.index[i], "卖出价": price, "原因": reason,
                     "R 倍数": done + left * (price - entry_price) / risk,
                     "最大浮盈": best, "最大浮亏": worst, "根数": i - entry_i})
        holding = False
    return pd.DataFrame(rows, columns=["买入日", "买入价", "初始止损", "R", "卖出日", "卖出价", "原因",
                                       "R 倍数", "最大浮盈", "最大浮亏", "根数"])

def expectancy(r: pd.Series | np.ndarray) -> pd.Series:
    """一串 R 倍数的成绩单。

    期望值 = 胜率 × 平均盈利 − 败率 × 平均亏损，它算出来就是这串 R 的平均数——
    那条公式没有多给出任何信息，它的用处是告诉你**能从哪两头去改**：
    提高胜率，或者提高盈亏比。第 23 篇的数据说明这两头往往是此消彼长的。
    """
    r = pd.Series(r).dropna()
    wins, losses = r[r > 0], r[r <= 0]
    win_rate = len(wins) / len(r) if len(r) else np.nan
    avg_win = wins.mean() if len(wins) else 0.0
    avg_loss = -losses.mean() if len(losses) else 0.0
    return pd.Series({
        "交易数": float(len(r)),
        "胜率": win_rate,
        "平均盈利": avg_win,
        "平均亏损": avg_loss,
        "盈亏比": avg_win / avg_loss if avg_loss else np.inf,
        "期望值": win_rate * avg_win - (1 - win_rate) * avg_loss,
        "中位数": r.median(),
        "最好的一笔": r.max(),
        "最差的一笔": r.min(),
    })

def test_stop_fills_at_the_close_that_broke_it():
    bars = frame(FLAT + [(100, 103, 99, 102), (102, 103, 88, 89), (89, 90, 85, 86)])
    trades = K.run(bars, pd.Series([False] * 5 + [True] + [False] * 3, index=bars.index),
                   K.Exit(**PERCENT, trail="none"))
    one = trades.iloc[0]
    assert one["原因"] == "止损" and one["卖出价"] == pytest.approx(89.0)
    assert one["R 倍数"] == pytest.approx(-1.1)                       # 收盘触发会穿过去，亏的比 1R 多
    assert one["最大浮亏"] == pytest.approx(-1.2)                     # 盘中一度到过 88

def test_same_bar_is_counted_as_a_stop():
    plan = K.Exit(**PERCENT, trail="none", target_r=1.0, trigger="extreme")
    bars = frame(FLAT + [(100, 103, 99, 102), (102, 111, 89, 95)])
    trades = K.run(bars, pd.Series([False] * 5 + [True] + [False] * 2, index=bars.index), plan)
    one = trades.iloc[0]
    assert one["原因"] == "同一根"                                     # 110 和 90 在同一根里都碰到了
    assert one["卖出价"] == pytest.approx(90.0)                        # 按止损算，保守的那一边

def test_agrees_with_rules_run_on_the_same_setup():
    """同样的入场、同样的 3 ATR 吊灯、同样的收盘触发，两个模块应该给出同一批交易。"""
    rng = np.random.default_rng(23)
    steps = rng.normal(0.0005, 0.02, 600)
    close = pd.Series(100 * np.exp(np.cumsum(steps)),
                      index=pd.date_range("2020-01-01", periods=600, freq="D"))
    df = pd.DataFrame({"open": close.shift(1).bfill(), "high": close * 1.01,
                       "low": close * 0.99, "close": close})
    entry = (close >= close.rolling(20).max()).fillna(False)
    never = pd.Series(False, index=df.index)
    mine = K.run(df, entry, K.Exit(stop="atr", k=3.0, trail="chandelier", trail_k=3.0, trigger="close"))
    theirs = R.run(df, R.Rule(entry=entry, exit=never, fill="next_open",
                              stop="chandelier", k=3.0, trigger="close"))[2]
    assert len(mine) == len(theirs) > 5
    assert list(mine["买入日"]) == list(theirs["买入日"])
    assert mine["卖出价"].to_numpy() == pytest.approx(theirs["卖出价"].to_numpy())

210 passed in 0.79s

178 passed, 32 skipped in 0.75s

这笔交易最后在 2021-01-12 以 34051.24 出场，止损，24.89 个 R，持有 94 根 K 线
期间盘中最高到过 33.43 个 R（41950.00），最大浮亏 -0.0001 个 R（最低 11050.51，就在买入的那一根上）

三种做法在这一笔上的结果（决策点收盘 12968.52，2.08 R）：
全部离场     2.08
平一半     13.48
拿住      24.89

同一批交易里，另外三笔也在某一天到过 +2R：
  2019-06-16 买入，2019-06-25 收盘 2.33 R，最后 1.95 R（止损，又拿了 2 根）
  2020-07-23 买入，2020-07-27 收盘 2.43 R，最后 1.00 R（止损，又拿了 38 根）
  2021-02-04 买入，2021-02-21 收盘 2.09 R，最后 1.00 R（止损，又拿了 4 根）

rows = []
for name, (df, _) in MARKETS.items():
    t = K.run(df, entries(df), CHANDELIER, exits=deaths(df))
    close = df["close"]
    for _, x in t.iterrows():
        i, j = df.index.get_loc(x["买入日"]), df.index.get_loc(x["卖出日"])
        r = (close.iloc[i:j + 1].to_numpy() - x["买入价"]) / x["R"]
        hit = np.nonzero(r >= 2.0)[0]
        if len(hit):
            rows.append({"标的": name, "买入日": x["买入日"], "到 2R 那根": df.index[i + hit[0]],
                         "全部离场": r[hit[0]], "拿住": x["R 倍数"], "还要拿几根": j - i - int(hit[0])})
reached = pd.DataFrame(rows)
reached["平一半"] = (reached["全部离场"] + reached["拿住"]) / 2

五个序列合计 205 笔交易在某一根收盘时浮盈到过 +2R
          交易数   拿住平均  拿住中位数   最好的一笔  不如直接走
标的                                        
SPY 日线      8  2.332  1.717   5.309  0.625
AAPL 日线    11  2.371  2.106   6.366  0.455
BTC 日线      9  4.914  2.223  24.887  0.556
BTC 4 小时   45  3.434  2.049  17.546  0.533
BTC 1 小时  132  2.979  2.244  21.134  0.538

       到 2R 就全部离场      平一半       拿住
交易数       205.000  205.000  205.000
胜率          1.000    1.000    0.995
平均盈利        2.377    2.742    3.122
平均亏损        0.000    0.000    0.038
盈亏比           inf      inf   81.517
期望值         2.377    2.742    3.106
中位数         2.179    2.280    2.209
最好的一笔       8.453   13.844   24.887
最差的一笔       2.001    1.004   -0.038

拿住比直接走更差的比例：53.7%
最终不到 2R 的：43.4%；不到 1R 的：11.2%；倒亏的：0.5%
最终 ≥ 4R 的只有 21.5%，但它们贡献了「拿住」全部 R 的 50.3%
三种做法的标准差：全部离场 0.68，平一半 1.78，拿住 3.16

PLANS = {"A 结构止损，不动": K.Exit(stop="structure", lookback=20, buffer=0.5, trail="none"),
         "B 3 ATR 止损，不动": K.Exit(stop="atr", k=3.0, trail="none"),
         "C 3 ATR 吊灯跟踪": K.Exit(stop="atr", k=3.0, trail="chandelier", trail_k=3.0),
         "D 时间止损：拿满 20 根": K.Exit(stop="atr", k=3.0, trail="none", max_bars=20)}
rng = np.random.default_rng(23)
rows, distributions = [], {}
for name, (df, periods) in MARKETS.items():
    years = len(df) / periods
    for label, plan in PLANS.items():
        t = K.run(df, entries(df), plan, exits=deaths(df))
        r = t["R 倍数"]
        score = K.expectancy(r)
        curve = r.cumsum()
        boot = np.array([rng.choice(r, len(r)).sum() for _ in range(2000)])
        distributions.setdefault(label, []).append(r)
        rows.append({"标的": name, "出场方式": label, "交易数": int(score["交易数"]), "胜率": score["胜率"],
                     "平均盈利": score["平均盈利"], "平均亏损": score["平均亏损"], "盈亏比": score["盈亏比"],
                     "每笔期望 R": score["期望值"], "合计 R": r.sum(),
                     "合计 R 的 95% 区间": f"[{np.percentile(boot, 2.5):.0f}, {np.percentile(boot, 97.5):.0f}]",
                     "最大回撤 R": (curve - curve.cummax()).min(), "在场时间": t["根数"].sum() / len(df),
                     "平均持有根数": t["根数"].mean(), "最大一笔占合计": r.max() / r.sum(),
                     "满仓复利年化": (t["卖出价"] / t["买入价"]).prod() ** (1 / years) - 1})
compare = pd.DataFrame(rows)

--- BTC 日线 ---
          出场方式  交易数    胜率  平均盈利  平均亏损   盈亏比  每笔期望 R   合计 R 合计 R 的 95% 区间  最大回撤 R  在场时间  平均持有根数  最大一笔占合计  满仓复利年化
     A 结构止损，不动    9 0.556 4.352 0.909 4.787   2.014 18.123      [-3, 48]  -1.737 0.454 166.556    0.771   0.191
 B 3 ATR 止损，不动   10 0.500 6.589 1.024 6.437   2.782 27.825      [-2, 65]  -2.241 0.442 145.900    0.605   0.213
  C 3 ATR 吊灯跟踪   30 0.433 3.581 0.719 4.979   1.144 34.329      [-3, 92]  -3.597 0.227  25.033    0.725   0.185
D 时间止损：拿满 20 根   45 0.511 1.712 0.917 1.867   0.427 19.200      [-2, 44]  -5.036 0.234  17.156    0.281   0.113

五个序列的交易合起来：
       A 结构止损，不动  B 3 ATR 止损，不动  C 3 ATR 吊灯跟踪  D 时间止损：拿满 20 根
交易数      339.000        385.000      1119.000        1583.000
胜率         0.357          0.317         0.399           0.489
平均盈利       5.313          7.097         1.641           1.169
平均亏损       0.923          1.098         0.647           0.750
盈亏比        5.754          6.465         2.535           1.560
期望值        1.303          1.499         0.265           0.189
中位数       -0.468         -1.015        -0.233          -0.026
最好的一笔     55.965         75.302        24.887          13.451
最差的一笔     -2.516         -4.072        -3.218          -4.286

      标的  交易数    胜率   盈亏比  每笔期望 R    合计 R 合计 R 的 95% 区间  最大回撤 R
  SPY 日线   39 0.436 2.367   0.282  11.017      [-5, 29]  -2.685
 AAPL 日线   37 0.514 2.192   0.458  16.952      [-1, 37]  -3.724
  BTC 日线   30 0.433 4.979   1.144  34.329      [-3, 92]  -3.597
BTC 4 小时  186 0.468 3.077   0.567 105.530     [48, 173] -10.744
BTC 1 小时  827 0.375 2.307   0.155 128.445     [37, 225] -20.263

一、初始止损            进场价下方 3.0 倍 ATR
二、止损跟不跟    吊灯：最高价往下 3.0 倍 ATR，只上移
三、目标价                 不设目标，让它自己走完
四、最多拿多久                        不限

pool = []
for name, (df, _) in MARKETS.items():
    t = K.run(df, entries(df), CHANDELIER, exits=deaths(df))
    t["标的"] = name
    pool.append(t)
all_trades = pd.concat(pool, ignore_index=True)
winners = all_trades[all_trades["R 倍数"] > 0]
losers = all_trades[all_trades["R 倍数"] <= 0]
print(f"五个序列合计 {len(all_trades)} 笔：赚钱 {len(winners)} 笔，亏钱 {len(losers)} 笔")
print(pd.DataFrame({"赚钱的交易 · 最大浮亏": winners["最大浮亏"].quantile([.5, .75, .9, .95]),
                    "亏钱的交易 · 最大浮亏": losers["最大浮亏"].quantile([.5, .75, .9, .95]),
                    "亏钱的交易 · 最大浮盈": losers["最大浮盈"].quantile([.5, .75, .9, .95])}).round(2).to_string())

五个序列合计 1119 笔：赚钱 446 笔，亏钱 673 笔
      赚钱的交易 · 最大浮亏  亏钱的交易 · 最大浮亏  亏钱的交易 · 最大浮盈
0.50         -0.26         -0.80          0.40
0.75         -0.13         -0.55          0.67
0.90         -0.06         -0.36          0.93
0.95         -0.03         -0.28          1.16

赚钱的交易里，最大浮亏没超过 0.5R 的占 80.5%
但把止损收紧，代价是打掉一部分赢家：
  止损改放在 −0.3R（当初距离的 30%），赢家里有 41.5% 会先被打掉
  止损改放在 −0.5R（当初距离的 50%），赢家里有 19.5% 会先被打掉
  止损改放在 −0.7R（当初距离的 70%），赢家里有 8.5% 会先被打掉
  止损改放在 −1.0R（当初距离的 100%），赢家里有 1.6% 会先被打掉

亏钱的交易里，浮盈到过 1R 的只有 7.7%，到过 2R 的只有 0.3%
全部交易里最大浮亏跌穿 1R 的有 19.7%——收盘触发的止损盘中会被穿过去（第 20 篇的选择）