第 20 篇：时段与事件

                               open      high       low     close      成交均价   volume  trades
time                                                                                        
2024-04-13 20:04:00+00:00  63939.99  64222.11  63820.95  64119.33  63995.60   253.44    6785
2024-04-13 20:05:00+00:00  64119.33  64219.61  63701.97  63808.00  63959.77   182.04    7377
2024-04-13 20:06:00+00:00  63808.00  63884.26  63200.00  63441.18  63508.33   457.81   17504
2024-04-13 20:07:00+00:00  63476.12  63559.66  62000.00  62289.67  62711.54  1061.48   39578
2024-04-13 20:08:00+00:00  62287.98  62471.99  61300.00  61300.00  61904.61  1147.36   36381
2024-04-13 20:09:00+00:00  61312.01  61864.99  60660.57  61742.47  61096.35  1230.04   42068
2024-04-13 20:10:00+00:00  61762.43  62797.65  61558.19  61825.71  62161.93   762.74   33444
止损价 62271.55，第一根跌破它的分钟是 2024-04-13 20:07:00+00:00（北京时间 04-14 04:07，周日）
那一分钟：从 63476 跌到 62000，成交 39,578 笔，成交均价 62711.54（比止损价高 +0.71%）
19:45 的 66791 到 20:09 的 60661：24 分钟跌了 -9.2%
当晚 20 点这一小时成交 1,263 百万美元；上一个周六同一小时 29.9 百万美元，差 42 倍

hour_of_day = SS.utc_hour(hour.index)
by_hour = pd.DataFrame({"成交额占比": hour.groupby(hour_of_day)["quote_volume"].sum() / hour["quote_volume"].sum(),
                        "平均振幅": ((hour["high"] - hour["low"]) / hour["open"]).groupby(hour_of_day).mean(),
                        "平均笔数": hour.groupby(hour_of_day)["trades"].mean()})
by_hour.index.name = "UTC 小时"
print(by_hour.round(4).to_string())
print("\n按时段：")
print(SS.profile(hour, SS.session_of(hour.index)).round(4).to_string())

         成交额占比    平均振幅         平均笔数
UTC 小时                             
0       0.0417  0.0107   84601.4100
1       0.0381  0.0096   80878.3617
2       0.0356  0.0088   74694.3775
3       0.0330  0.0081   67448.2103
4       0.0315  0.0081   63270.5006
5       0.0314  0.0079   62825.2382
6       0.0338  0.0081   66662.5184
7       0.0384  0.0083   72101.1112
8       0.0401  0.0090   76126.2374
9       0.0384  0.0086   73652.0537
10      0.0380  0.0088   72602.5188
11      0.0380  0.0089   73134.6875
12      0.0470  0.0103   88964.5258
13      0.0556  0.0112  111887.4154
14      0.0654  0.0121  135253.6426
15      0.0628  0.0115  128922.6241
16      0.0565  0.0114  114548.9312
17      0.0470  0.0100   98362.1088
18      0.0440  0.0096   91786.0400
19      0.0428  0.0096   87672.4321
20      0.0415  0.0101   82115.1355
21      0.0329  0.0095   70264.8788
22      0.0332  0.0097   70103.2518
23      0.0334  0.0093   66759.9806

按时段：
               K线数   成交额占比    平均振幅    平均涨跌   涨跌标准差
组                                                 
亚洲 00-07     23042  0.2450  0.0088 -0.0000  0.0073
欧洲 07-13     19778  0.2400  0.0090  0.0001  0.0074
美国 13-21     26393  0.4155  0.0107  0.0001  0.0082
美股收盘后 21-24   9900  0.0996  0.0095  0.0002  0.0076

weekend = SS.is_weekend(hour.index)
print(SS.profile(hour, weekend.map({True: "周六周日", False: "周一到周五"})).round(4).to_string())
impact = (hour["close"] / hour["open"] - 1).abs() / (hour["quote_volume"] / 1e8) * 100   # 每成交 1 亿美元，价格走了百分之几
print("\n价格冲击：这一小时里每成交 1 亿美元，价格平均走了多少（中位数，越大越薄）")
print("  按周末：", impact.groupby(weekend.map({True: "周六周日", False: "周一到周五"}).to_numpy()).median().round(3).to_dict())
print("  按时段：", impact.groupby(SS.session_of(hour.index).to_numpy()).median().round(3).to_dict())
weekend_share = weekend.mean()
print(f"周末占全部小时的 {weekend_share:.1%}，但只占成交额的 {hour.loc[weekend.to_numpy(), 'quote_volume'].sum() / hour['quote_volume'].sum():.1%}")
yearly = hour.groupby([hour.index.year, weekend.to_numpy()])["quote_volume"].sum().unstack()
yearly["周末占比"] = yearly[True] / (yearly[True] + yearly[False])
print("\n每年周末成交额占比：", yearly["周末占比"].round(3).to_dict())

         K线数   成交额占比    平均振幅    平均涨跌   涨跌标准差
组                                           
周一到周五  56467  0.8029  0.0102  0.0001  0.0081
周六周日   22646  0.1971  0.0079  0.0000  0.0065

价格冲击：这一小时里每成交 1 亿美元，价格平均走了多少（中位数，越大越薄）
  按周末： {'周一到周五': 0.585, '周六周日': 0.661}
  按时段： {'亚洲 00-07': 0.645, '欧洲 07-13': 0.557, '美国 13-21': 0.57, '美股收盘后 21-24': 0.734}
周末占全部小时的 28.6%，但只占成交额的 19.7%

每年周末成交额占比： {2017: 0.282, 2018: 0.24, 2019: 0.241, 2020: 0.224, 2021: 0.236, 2022: 0.193, 2023: 0.196, 2024: 0.157, 2025: 0.172, 2026: 0.184}

spike = (hour["low"] / hour["open"] - 1 <= -0.03) | (hour["high"] / hour["open"] - 1 >= 0.03)
print(f"一小时内偏离开盘价 3% 以上的小时：{int(spike.sum())} 个，占 {spike.mean():.2%}")
compare = pd.DataFrame({"全部小时": SS.session_of(hour.index).value_counts(normalize=True),
                        "插针小时": SS.session_of(hour.index[spike.to_numpy()]).value_counts(normalize=True)})
compare["插针 ÷ 全部"] = compare["插针小时"] / compare["全部小时"]
print(compare.round(3).to_string())
weekend_spike = SS.is_weekend(hour.index[spike.to_numpy()]).mean()
print(f"插针发生在周末的比例 {weekend_spike:.1%}，周末本身占 {weekend_share:.1%}")
thin = hour["quote_volume"].rolling(24 * 7, min_periods=24).median()
print("插针小时的成交额 ÷ 最近一周中位成交额：", round(float((hour["quote_volume"] / thin)[spike.to_numpy()].median()), 2),
      "；普通小时：", round(float((hour["quote_volume"] / thin)[~spike.to_numpy()].median()), 2))
big = hour["quote_volume"] >= hour["quote_volume"].quantile(0.99)     # 成交额最大的 1% 的小时
print(f"成交额最大的 1% 的小时（{int(big.sum())} 个）里，平均振幅 {((hour['high'] - hour['low']) / hour['open'])[big.to_numpy()].mean():.2%}；"
      f"其中周末的 {((hour['high'] - hour['low']) / hour['open'])[(big & weekend).to_numpy()].mean():.2%}，"
      f"工作日的 {((hour['high'] - hour['low']) / hour['open'])[(big & ~weekend).to_numpy()].mean():.2%}")

一小时内偏离开盘价 3% 以上的小时：1684 个，占 2.13%
              全部小时   插针小时  插针 ÷ 全部
美国 13-21     0.334  0.398    1.193
亚洲 00-07     0.291  0.260    0.891
欧洲 07-13     0.250  0.223    0.891
美股收盘后 21-24  0.125  0.120    0.959
插针发生在周末的比例 20.5%，周末本身占 28.6%
插针小时的成交额 ÷ 最近一周中位成交额： 2.93 ；普通小时： 0.99
成交额最大的 1% 的小时（792 个）里，平均振幅 3.06%；其中周末的 3.36%，工作日的 3.03%

rows = []
for name, df in [("SPY", spy), ("AAPL", aapl)]:
    overnight = df["open"] / df["close"].shift(1) - 1
    intraday = df["close"] / df["open"] - 1
    total = df["close"].iloc[-1] / df["close"].iloc[0] - 1
    rows.append({"标的": name, "总涨幅": total, "只吃隔夜": (1 + overnight).prod() - 1, "只吃日内": (1 + intraday).prod() - 1,
                 "隔夜平均": overnight.mean(), "日内平均": intraday.mean(),
                 "隔夜标准差": overnight.std(), "日内标准差": intraday.std(),
                 "隔夜方差占比": overnight.var() / (overnight.var() + intraday.var())})

  标的     总涨幅   只吃隔夜    只吃日内   隔夜平均   日内平均  隔夜标准差  日内标准差  隔夜方差占比
 SPY  2.5182 1.3953  0.4848 0.0004 0.0002 0.0073 0.0085  0.4214
AAPL 11.5369 0.1337 10.2246 0.0001 0.0011 0.0117 0.0143  0.3987

sessions = nyse.sessions_in_range("2016-09-15", "2026-09-15")
expiry = SS.third_fridays("2016-09-15", "2026-09-15")
quad = SS.third_fridays("2016-09-15", "2026-09-15", months=(3, 6, 9, 12))
calendar = {"月度期权到期日（第三个周五）": expiry, "四巫日（3/6/9/12 月第三个周五）": quad,
            "月末最后一个交易日": SS.period_ends(sessions), "季末最后一个交易日": SS.period_ends(sessions, "QE"),
            "提前收盘的半日": pd.DatetimeIndex([d.tz_localize(None) for d in nyse.early_closes])}
rows = []
for name, days in calendar.items():
    for symbol, df in [("SPY", spy), ("AAPL", aapl)]:
        relative_volume = df["volume"] / df["volume"].rolling(20).median().shift(1)
        swing = (df["high"] - df["low"]) / df["open"]
        picked = df.index.intersection(pd.DatetimeIndex(days))
        rows.append({"日子": name, "标的": symbol, "天数": len(picked),
                     "成交量 ÷ 前 20 天中位": relative_volume.loc[picked].median(),
                     "平常": relative_volume.median(), "振幅": swing.loc[picked].median(), "平常振幅": swing.median()})
print(pd.DataFrame(rows).to_string(index=False, float_format=lambda v: f"{v:.3f}"))

                  日子   标的  天数  成交量 ÷ 前 20 天中位    平常    振幅  平常振幅
      月度期权到期日（第三个周五）  SPY 116           1.289 0.985 0.009 0.009
      月度期权到期日（第三个周五） AAPL 116           1.197 0.982 0.016 0.018
四巫日（3/6/9/12 月第三个周五）  SPY  39           1.508 0.985 0.010 0.009
四巫日（3/6/9/12 月第三个周五） AAPL  39           1.997 0.982 0.019 0.018
           月末最后一个交易日  SPY 121           1.246 0.985 0.009 0.009
           月末最后一个交易日 AAPL 121           1.143 0.982 0.017 0.018
           季末最后一个交易日  SPY  41           1.247 0.985 0.009 0.009
           季末最后一个交易日 AAPL  41           0.995 0.982 0.017 0.018
             提前收盘的半日  SPY  21           0.585 0.985 0.005 0.009
             提前收盘的半日 AAPL  21           0.527 0.982 0.011 0.018

fomc = SS.fomc_dates(2016, 2026)
earnings = SS.sec_filing_dates(320193)                               # 苹果的 CIK
earnings = earnings[(earnings >= "2016-09-15") & (earnings <= "2026-09-15")]
print(f"FOMC 公布利率的日子 {len(fomc)} 天（{fomc[0].date()} 到 {fomc[-1].date()}）；"
      f"苹果发财报 {len(earnings)} 次（8-K 的 2.02 条款）")
for name, df, events, offset in [("SPY 遇上 FOMC", spy, fomc, 0), ("BTC 遇上 FOMC", day, fomc, 0),
                                 ("AAPL 遇上自己的财报", aapl, earnings, 1)]:
    swing = ((df["high"] - df["low"]) / df["open"]).rename("振幅")
    study = SS.event_study(swing, events, before=3, after=3, offset=offset)
    print(f"\n{name}（振幅 = (最高 - 最低) ÷ 开盘）：")
    print(study.to_string(float_format=lambda v: f"{v:.4f}"))
    jump = (df["open"] / df["close"].shift(1) - 1).abs().rename("隔夜跳空")
    window = SS.event_window(jump, events, before=0, after=1, offset=offset)
    print(f"  事件后第一根的隔夜跳空中位数 {window[0].median():.4f}，平常 {jump.median():.4f}")

FOMC 公布利率的日子 92 天（2016-01-27 到 2026-09-16）；苹果发财报 41 次（8-K 的 2.02 条款）

SPY 遇上 FOMC（振幅 = (最高 - 最低) ÷ 开盘）：
       平均    中位数  事件数  平常的平均  平常的中位数
-3 0.0120 0.0088   86 0.0114  0.0088
-2 0.0113 0.0076   86 0.0114  0.0088
-1 0.0118 0.0089   86 0.0114  0.0088
0  0.0153 0.0114   86 0.0114  0.0088
1  0.0141 0.0111   86 0.0114  0.0088
2  0.0144 0.0109   86 0.0114  0.0088
3  0.0126 0.0090   86 0.0114  0.0088
  事件后第一根的隔夜跳空中位数 0.0017，平常 0.0029

BTC 遇上 FOMC（振幅 = (最高 - 最低) ÷ 开盘）：
       平均    中位数  事件数  平常的平均  平常的中位数
-3 0.0490 0.0354   78 0.0496  0.0395
-2 0.0600 0.0459   78 0.0496  0.0395
-1 0.0478 0.0402   78 0.0496  0.0395
0  0.0555 0.0457   78 0.0496  0.0395
1  0.0533 0.0466   78 0.0496  0.0395
2  0.0493 0.0426   78 0.0496  0.0395
3  0.0387 0.0298   78 0.0496  0.0395
  事件后第一根的隔夜跳空中位数 0.0000，平常 0.0000

AAPL 遇上自己的财报（振幅 = (最高 - 最低) ÷ 开盘）：
       平均    中位数  事件数  平常的平均  平常的中位数
-3 0.0190 0.0168   41 0.0205  0.0176
-2 0.0202 0.0177   41 0.0205  0.0176
-1 0.0206 0.0202   41 0.0205  0.0176
0  0.0349 0.0317   41 0.0205  0.0176
1  0.0263 0.0215   41 0.0205  0.0176
2  0.0215 0.0183   41 0.0205  0.0176
3  0.0223 0.0217   41 0.0205  0.0176
  事件后第一根的隔夜跳空中位数 0.0313，平常 0.0043

"""talab.sessions：交易时段与事件日历。第 20 篇。

两件事：

1. **时段**：一天里的每个小时不一样，一周里的每一天也不一样。加密 24 小时开着，但成交量随
   亚洲、欧洲、美国三个时段起落；周末是一周里最薄的时候。
2. **事件**：有些日子是提前知道的——期权到期、月末、FOMC 公布利率、公司发财报。事件日历
   是一张「哪天会有事」的表，事件研究是「事件前后发生了什么」的统计。

时间一律按 UTC。索引带时区的用它自己的时区换算成 UTC，不带时区的当成 UTC。
"""

# 三个时段其实是重叠的（伦敦和纽约有三小时重叠），这里按「哪个市场在主导」把一天切成不重叠的四段。
SESSIONS = {"亚洲 00-07": (0, 7), "欧洲 07-13": (7, 13), "美国 13-21": (13, 21), "美股收盘后 21-24": (21, 24)}


def utc_hour(index: pd.DatetimeIndex) -> np.ndarray:
    """每个时间点的 UTC 小时。"""
    index = pd.DatetimeIndex(index)
    return (index.tz_convert("UTC") if index.tz is not None else index).hour.to_numpy()


def session_of(index: pd.DatetimeIndex, sessions: dict = SESSIONS) -> pd.Series:
    """每根 K 线属于哪个时段（按 UTC 小时，左闭右开）。"""
    hour = utc_hour(index)
    out = pd.Series(pd.NA, index=index, dtype="object")
    for name, (start, end) in sessions.items():
        out[(hour >= start) & (hour < end)] = name
    return out

def third_fridays(start, end, months: tuple = tuple(range(1, 13))) -> pd.DatetimeIndex:
    """每月第三个周五：美股月度期权到期日。months 只留 3、6、9、12 就是「四巫日」。

    ⚠️ 这是日历上的第三个周五，遇到假日（例如 2020-04-10 耶稣受难日）实际到期日会提前一天，
    用 period_ends 那种「交易日历」口径的函数去对齐。
    """
    days = pd.date_range(start, end, freq="D")
    fridays = days[(days.dayofweek == 4) & days.month.isin(months)]
    order = fridays.to_series().groupby([fridays.year, fridays.month]).cumcount()
    return pd.DatetimeIndex(fridays[order == 2])


def period_ends(sessions: pd.DatetimeIndex, freq: str = "ME") -> pd.DatetimeIndex:
    """每个月（freq="ME"）或每个季度（freq="QE"）的最后一个交易日。"""
    sessions = pd.DatetimeIndex(sessions)
    return pd.DatetimeIndex(pd.Series(sessions, index=sessions).resample(freq).last().dropna())


def parse_fomc_page(html: str) -> list[str]:
    """从美联储的会议日历页面里取出所有货币政策声明的日期（YYYY-MM-DD）。

    声明的链接形如 /newsevents/pressreleases/monetary20240320a.htm，日期就是会议最后一天，
    也就是利率公布的那一天。
    """
    found = re.findall(r"/newsevents/pressreleases/monetary(\d{8})a\.htm", html)
    return sorted({f"{d[:4]}-{d[4:6]}-{d[6:]}" for d in found})


def fomc_dates(start_year: int = 2016, end_year: int = 2026) -> pd.DatetimeIndex:
    """FOMC 公布利率的日期。近几年在 fomccalendars.htm，更早的在每年一张的历史页面上。"""
    pages = ["https://www.federalreserve.gov/monetarypolicy/fomccalendars.htm"]
    pages += [f"https://www.federalreserve.gov/monetarypolicy/fomchistorical{year}.htm"
              for year in range(start_year, min(end_year, 2021))]
    dates = {d for page in pages for d in parse_fomc_page(_get(page))}
    picked = pd.DatetimeIndex(sorted(dates))
    return picked[(picked.year >= start_year) & (picked.year <= end_year)]

def parse_sec_submissions(payload: dict, form: str = "8-K", item: str | None = None) -> list[str]:
    """从 SEC EDGAR 的备案清单里取出日期。item="2.02" 是「业绩公告」，也就是财报发布日。"""
    filings = payload["filings"]["recent"] if "filings" in payload else payload
    rows = zip(filings["filingDate"], filings["form"], filings.get("items", [""] * len(filings["form"])))
    return sorted({date for date, kind, items in rows if kind == form and (item is None or item in items)})


def sec_filing_dates(cik: int, form: str = "8-K", item: str | None = "2.02") -> pd.DatetimeIndex:
    """一家公司向 SEC 提交某类文件的日期。默认取 8-K 的 2.02 条款：公布季度业绩。

    ⚠️ 备案日是公司发布的那一天。苹果在美股收盘后发财报，所以价格反应在**第二天**。
    """
    base = f"https://data.sec.gov/submissions/CIK{cik:010d}.json"
    payload = json.loads(_get(base))
    dates = set(parse_sec_submissions(payload, form, item))
    for older in payload["filings"].get("files", []):
        dates |= set(parse_sec_submissions(json.loads(_get(f"https://data.sec.gov/submissions/{older['name']}")),
                                           form, item))
    return pd.DatetimeIndex(sorted(dates))


def _get(url: str) -> str:
    request = urllib.request.Request(url, headers={"User-Agent": "talab course (contact: [email protected])"})
    with urllib.request.urlopen(request, timeout=60) as response:
        return response.read().decode("utf-8", "replace")

def event_window(values: pd.Series, events, before: int = 5, after: int = 5, offset: int = 0) -> pd.DataFrame:
    """把每个事件对齐到同一张表：每行一个事件，列是 -before 到 +after 根 K 线。

    事件日不在索引里（休市、或者 values 是别的市场）时，取它之后第一个有数据的位置。
    offset 用来处理「盘后公布」：offset=1 表示把第 0 根算作事件日的下一根。
    窗口伸出数据范围的事件直接丢掉。
    """
    index = values.index
    rows, kept = [], []
    for event in pd.DatetimeIndex(events):
        when = event.tz_localize(index.tz) if index.tz is not None and event.tz is None else event
        position = index.searchsorted(when) + offset
        if position - before < 0 or position + after >= len(index):
            continue
        rows.append(values.to_numpy()[position - before: position + after + 1])
        kept.append(event)
    return pd.DataFrame(rows, index=pd.DatetimeIndex(kept), columns=range(-before, after + 1))


def event_study(values: pd.Series, events, before: int = 5, after: int = 5, offset: int = 0) -> pd.DataFrame:
    """事件窗口的平均值、中位数和事件数；最后两列是「所有日子」的平均和中位数，用来当基准。"""
    window = event_window(values, events, before, after, offset)
    return pd.DataFrame({"平均": window.mean(), "中位数": window.median(), "事件数": window.count(),
                         "平常的平均": values.mean(), "平常的中位数": values.median()})

def test_parse_fomc_page_by_hand():
    html = ('<a href="/newsevents/pressreleases/monetary20240320a.htm">HTML</a>'
            '<a href="/monetarypolicy/files/monetary20240320a1.pdf">PDF</a>'
            '<a href="/newsevents/pressreleases/monetary20240501a.htm">HTML</a>'
            '<a href="/newsevents/pressreleases/monetary20240320a.htm">重复的链接</a>')
    assert S.parse_fomc_page(html) == ["2024-03-20", "2024-05-01"]     # 去重、排序，PDF 不算


def test_parse_sec_submissions_by_hand():
    payload = {"filings": {"recent": {
        "filingDate": ["2024-05-02", "2024-04-10", "2024-02-01", "2024-01-15"],
        "form": ["8-K", "8-K", "8-K", "10-Q"],
        "items": ["2.02,9.01", "5.02", "2.02,9.01", ""]}}}
    assert S.parse_sec_submissions(payload, item="2.02") == ["2024-02-01", "2024-05-02"]   # 只留业绩公告
    assert len(S.parse_sec_submissions(payload)) == 3                              # 不挑条款就是全部 8-K
    assert S.parse_sec_submissions(payload, form="10-Q") == ["2024-01-15"]


def test_event_window_alignment_by_hand():
    days = pd.date_range("2024-01-01", periods=10, freq="D", tz="UTC")
    values = pd.Series(np.arange(10, dtype=float), index=days)
    window = S.event_window(values, ["2024-01-05"], before=2, after=2)
    assert window.columns.tolist() == [-2, -1, 0, 1, 2]
    assert window.iloc[0].tolist() == [2, 3, 4, 5, 6]                  # 事件日的值是 4（1 月 5 日）
    assert S.event_window(values, ["2024-01-05"], 2, 2, offset=1).iloc[0].tolist() == [3, 4, 5, 6, 7]
    assert len(S.event_window(values, ["2024-01-01"], before=2, after=2)) == 0      # 窗口伸出数据范围，丢掉
    # 事件日不在索引里（当天休市）：取之后第一个有数据的位置
    trading = values.drop(days[4])
    assert S.event_window(trading, ["2024-01-05"], 1, 1).iloc[0].tolist() == [3, 5, 6]

177 passed in 0.71s

def mainline(df, k=3.0, n_atr=14, breakout=20, fast=50, slow=200, trigger="low", skip=None):
    """主线策略 v1（第 15 篇）加两个开关。

    trigger="low"：盘中最低价碰到止损价就出场（v1 的做法）；trigger="close"：只有收盘价跌破才出场。
    skip：一个布尔序列，标出「这根 K 线不许触发止损」的日子（比如周末），这些日子只在收盘时判断。
    """
    o, h, l, c = (df[x].to_numpy(float) for x in OHLC)
    atr = I.atr(df["high"], df["low"], df["close"], n_atr).to_numpy()
    trend = (I.sma(df["close"], fast) > I.sma(df["close"], slow)).to_numpy()
    quiet = np.zeros(len(c), bool) if skip is None else np.asarray(skip, bool)
    first = df.index.get_loc(I.sma(df["close"], slow).first_valid_index())
    r, held, trades = np.zeros(len(c)), np.zeros(len(c)), []
    holding = buy = sell = locked = False
    for i in range(first, len(c)):
        if holding:
            stop, base = max(stop, highest - k * atr[i - 1]), c[i - 1]
        elif buy:
            holding, buy, entry, entry_i, highest = True, False, o[i], i, o[i]
            stop, base = o[i] - k * atr[i - 1], o[i]
        if holding:
            held[i] = 1
            intraday = trigger == "low" and not quiet[i]
            exit_price = reason = None
            if sell:
                exit_price, reason = o[i], "趋势"
            elif o[i] <= stop:
                exit_price, reason = o[i], "止损（跳空）"
            elif intraday and l[i] <= stop:
                exit_price, reason = stop, "止损"
            elif not intraday and c[i] <= stop:
                exit_price, reason = c[i], "止损（收盘）"
            if reason is None:
                r[i], highest = c[i] / base - 1, max(highest, h[i])
            else:
                r[i] = exit_price / base - 1
                trades.append((df.index[entry_i], entry, df.index[i], exit_price, reason, stop))
                holding, sell, locked = False, False, reason.startswith("止损")
        if holding:
            sell = not trend[i]
        elif locked:
            if trend[i] and c[i] > c[i - breakout:i].max():
                buy, locked = True, False
        else:
            buy = bool(trend[i])
    index = df.index[first:]
    trades = pd.DataFrame(trades, columns=["买入日", "买入价", "卖出日", "卖出价", "原因", "止损价"])
    trades["收益"] = trades["卖出价"] / trades["买入价"] - 1
    return pd.Series(r[first:], index=index), pd.Series(held[first:], index=index), trades

returns, holding, trades = mainline(day)
hit = trades[trades["卖出日"] == "2024-04-13"].iloc[0]
print("2024 年 4 月那一笔：")
print(hit.to_string())
print(f"止损价 {hit['止损价']:.2f}，那天的收盘价 {day.loc['2024-04-13', 'close']:.2f}，"
      f"收盘比止损价高 {day.loc['2024-04-13', 'close'] / hit['止损价'] - 1:.1%}")
print(f"下一次买回：{trades[trades['买入日'] > hit['卖出日']].iloc[0]['买入日'].date()}，"
      f"买入价 {trades[trades['买入日'] > hit['卖出日']].iloc[0]['买入价']:.2f}")

2024 年 4 月那一笔：
买入日    2024-04-09 00:00:00+00:00
买入价                      71620.0
卖出日    2024-04-13 00:00:00+00:00
卖出价                 62271.550597
原因                            止损
止损价                 62271.550597
收益                     -0.130528
止损价 62271.55，那天的收盘价 63924.51，收盘比止损价高 2.7%
下一次买回：2024-05-16，买入价 66206.51

止损之后：4 月 17 日最低收在 61277，4 月 19 日盘中最低 59600，5 月 16 日买回价 66206.51，比止损价高 6.3%
马上买回（4 月 14 日开盘）：买入价 63924.52，到 6 月 20 日 64869.99，+1.5%；期间最低收盘 58365
等规则买回（5 月 16 日）：买入价 66206.51，到 6 月 20 日 64869.99，-2.0%；期间最低收盘 64870

print("\n止损之后价格又回到止损价上方的比例：")
rows = []
for name, df in [("SPY", spy), ("AAPL", aapl), ("BTC", day)]:
    _, _, t = mainline(df)
    stops = t[t["原因"].str.startswith("止损")]
    back = {}
    for horizon in [0, 5, 20]:
        hits = []
        for when, level in zip(stops["卖出日"], stops["止损价"]):
            position = df.index.get_loc(when)
            window = df["close"].iloc[position: position + horizon + 1]
            hits.append(bool((window > level).any()))
        back[f"{horizon} 天内"] = np.mean(hits)
    rows.append({"标的": name, "止损次数": len(stops)} | back)
print(pd.DataFrame(rows).to_string(index=False, float_format=lambda v: f"{v:.3f}"))

止损之后价格又回到止损价上方的比例：
  标的  止损次数  0 天内  5 天内  20 天内
 SPY    49 0.592 0.898  0.918
AAPL    45 0.489 0.756  0.844
 BTC    39 0.641 0.846  0.949

rows = []
for name, df, periods in [("SPY", spy, 252), ("AAPL", aapl, 252), ("BTC", day, 365)]:
    for label, kwargs in [("v1：盘中触发", {}), ("v2：收盘触发", {"trigger": "close"}),
                          ("v2w：周末只看收盘", {"skip": SS.is_weekend(df.index)})]:
        r, held, t = mainline(df, **kwargs)
        equity = (1 + r).cumprod()
        stops = t[t["原因"].str.startswith("止损")]
        recovered = (df.loc[stops["卖出日"], "close"].to_numpy() > stops["止损价"].to_numpy()).mean() if len(stops) else np.nan
        rows.append({"标的": name, "版本": label, "年化": equity.iloc[-1] ** (periods / len(r)) - 1,
                     "最大回撤": (equity / equity.cummax() - 1).min(), "交易次数": len(t), "止损次数": len(stops),
                     "止损当天收盘又在止损价上方": recovered, "最差一笔": t["收益"].min()})
print(pd.DataFrame(rows).to_string(index=False, float_format=lambda v: f"{v:.3f}"))

  标的         版本    年化   最大回撤  交易次数  止损次数  止损当天收盘又在止损价上方   最差一笔
 SPY    v1：盘中触发 0.029 -0.140    49    49          0.592 -0.044
 SPY    v2：收盘触发 0.039 -0.117    40    40          0.100 -0.053
 SPY v2w：周末只看收盘 0.029 -0.140    49    49          0.592 -0.044
AAPL    v1：盘中触发 0.092 -0.213    45    45          0.489 -0.078
AAPL    v2：收盘触发 0.088 -0.293    39    39          0.154 -0.081
AAPL v2w：周末只看收盘 0.092 -0.213    45    45          0.489 -0.078
 BTC    v1：盘中触发 0.082 -0.565    41    39          0.641 -0.209
 BTC    v2：收盘触发 0.167 -0.531    31    29          0.000 -0.238
 BTC v2w：周末只看收盘 0.095 -0.567    40    38          0.632 -0.209

print("\n同一笔交易，两种触发方式的收益（按买入日配对）：")
for name, df in [("SPY", spy), ("AAPL", aapl), ("BTC", day)]:
    _, _, a = mainline(df)
    _, _, b = mainline(df, trigger="close")
    paired = a.set_index("买入日")["收益"].to_frame("v1").join(b.set_index("买入日")["收益"].to_frame("v2"), how="inner")
    diff = paired["v2"] - paired["v1"]
    boot = np.array([diff.iloc[rng.integers(0, len(diff), len(diff))].mean() for _ in range(2000)])
    print(f"{name}：配对上 {len(paired)} 笔，v2 减 v1 平均 {diff.mean():+.4f}，中位数 {diff.median():+.4f}，"
          f"v2 更好的占 {(diff > 0).mean():.1%}，p = {2 * min((boot <= 0).mean(), (boot >= 0).mean()):.3f}")

同一笔交易，两种触发方式的收益（按买入日配对）：
SPY：配对上 40 笔，v2 减 v1 平均 +0.0049，中位数 -0.0026，v2 更好的占 17.5%，p = 0.213
AAPL：配对上 39 笔，v2 减 v1 平均 +0.0051，中位数 -0.0074，v2 更好的占 10.3%，p = 0.731
BTC：配对上 31 笔，v2 减 v1 平均 +0.0537，中位数 -0.0135，v2 更好的占 25.8%，p = 0.297

overnight = aapl["open"] / aapl["close"].shift(1) - 1
after_earnings = pd.Series(False, index=aapl.index)
for date in earnings:
    position = aapl.index.searchsorted(date) + 1
    if position < len(aapl):
        after_earnings.iloc[position] = True
print(f"苹果 {len(earnings)} 次财报的第二天：隔夜跳空绝对值中位数 {overnight[after_earnings].abs().median():.2%}，"
      f"平常 {overnight[~after_earnings].abs().median():.2%}")
print(f"  这 {int(after_earnings.sum())} 天贡献了全部隔夜收益的 {overnight[after_earnings].sum() / overnight.sum():.1%}，"
      f"占天数的 {after_earnings.mean():.1%}")
buy_hold = (1 + aapl["close"].pct_change().fillna(0)).cumprod()
skip_days = after_earnings | after_earnings.shift(-1, fill_value=False)      # 财报当天和第二天都空仓
filtered = (1 + aapl["close"].pct_change().fillna(0).where(~skip_days, 0)).cumprod()
years = len(aapl) / 252
print(f"一直持有 AAPL：年化 {buy_hold.iloc[-1] ** (1 / years) - 1:.2%}，最大回撤 {(buy_hold / buy_hold.cummax() - 1).min():.1%}")
print(f"财报当天和第二天空仓：年化 {filtered.iloc[-1] ** (1 / years) - 1:.2%}，"
      f"最大回撤 {(filtered / filtered.cummax() - 1).min():.1%}，少持有 {skip_days.mean():.1%} 的时间")

苹果 41 次财报的第二天：隔夜跳空绝对值中位数 3.13%，平常 0.42%
  这 41 天贡献了全部隔夜收益的 67.0%，占天数的 1.6%
一直持有 AAPL：年化 28.86%，最大回撤 -38.5%
财报当天和第二天空仓：年化 24.04%，最大回撤 -40.5%，少持有 3.3% 的时间