EA13 Python/Backtrader 策略

四、核心抽象：Lines 与声明式编程

这是 Backtrader 最底层的设计，理解了它，你对框架就"通了"。Backtrader 里几乎所有数据都是 Line（线）：一根 K 线的收盘价序列、一条均线、一个 RSI，全是"线"。

1、Line 的索引

self.data.close[0] # 当前这根 K 线的收盘价（最常用）
self.data.close[-1] # 上一根
self.data.close[-5] # 5 根前
self.data.high[0] # 当前最高价
self.fast_ma[0] # 当前均线值

索引永远"向左看历史"：[0] 是当下，[-1] 是过去。绝不能在 next() 里写 [1]（那是未来，会被框架拒绝或导致未来函数）。

2、声明式 vs 命令式（关键区别）

在 __init__ 里，你可以直接对"线"做运算，得到的结果还是一条线（Backtrader 会"懒求值"，每根 K 线自动算）。在 next() 里，你用 [0] 取出当前标量值做判断。

class Declarative(bt.Strategy):
    def __init__(self):
        self.fast = bt.indicators.SMA(self.data.close, period=10)
        self.slow = bt.indicators.SMA(self.data.close, period=30)
self.rsi = bt.indicators.RSI(self.data.close, period=14)
        # 声明式：对线直接运算，得到"懒求值"的线对象
self.crossup = self.fast > self.slow # 仍是 LineBuffer
self.not_overbought = self.rsi < 70 # 仍是 LineBuffer

    def next(self):
        # 命令式：用 [0] 取当前标量判断
        if self.crossup[0] and self.not_overbought[0]:
            self.buy()

好处：声明式写法不用自己写 for 循环遍历历史，框架底层用 NumPy 向量化计算，又快又不会写出未来函数。新手最容易犯的错是：在 __init__ 里写 if self.fast[0] > self.slow[0]（此时 [0] 还是空值），正确做法是把比较留在 __init__ 生成线、在 next 取 [0]。

3、minperiod（预热期）自动推算

当你把多条线组合，Backtrader 自动取"最长周期"作为策略的 minperiod。比如 SMA(30) 会让策略前 29 根 K 线不进 next()，等均线有值才启动。你不用手动等，框架帮你管。

五、Strategy 生命周期方法全集

bt.Strategy 有一整套"钩子方法"，在不同阶段自动被调用。掌握它们，才能正确处理订单状态、统计成交、在指标未就绪时不乱下单。

1、标准骨架（强烈建议照抄）

import backtrader as bt

class MyStrategy(bt.Strategy):
    params = (('print_log', True),)

    def log(self, txt, dt=None):
        dt = dt or self.data.datetime.date(0)
        if self.p.print_log:
            print(f'{dt} {txt}')

    def __init__(self):
        self.dataclose = self.data.close
self.order = None # 记录"在途"订单
        self.buyprice = None
        self.buycomm = None

    def notify_order(self, order):
        # 订单提交/接受阶段：什么都不做，等最终结果
        if order.status in [order.Submitted, order.Accepted]:
            return
        # 订单完成
        if order.status == order.Completed:
            if order.isbuy():
self.log(f'BUY 成交价 {order.executed.price:.2f} 数量 {order.executed.size} 手续费 {order.executed.comm:.2f}')
                self.buyprice = order.executed.price
self.buycomm = order.executed.comm
            else:
                self.log(f'SELL 成交价 {order.executed.price:.2f} 数量 {order.executed.size} 手续费 {order.executed.comm:.2f}')
            self.order = None
        # 订单失败（取消 / 保证金不足 / 拒绝）
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('订单失败：Canceled/Margin/Rejected')
            self.order = None

    def notify_trade(self, trade):
        if not trade.isclosed:
            return
        self.log(f'交易平仓 毛利 {trade.pnl:.2f} 净利 {trade.pnlcomm:.2f}')

    def next(self):
if self.order: # 还有订单没处理完，先等
            return
        if not self.position:
            # 空仓时：满足买入条件
            if self.dataclose[0] > self.dataclose[-1]:
                self.log(f'买入信号 收盘价 {self.dataclose[0]:.2f}')
                self.order = self.buy()
        else:
            # 持仓时：满足卖出条件
            if self.dataclose[0] < self.dataclose[-1]:
                self.log(f'卖出信号 收盘价 {self.dataclose[0]:.2f}')
                self.order = self.sell()

为什么要记录 self.order？ 回测里订单通常不是"瞬间成交"，notify_order 会分多次回调。用 self.order 占位，避免在订单还没成交时反复发新单，这是新手最容易踩的坑。

六、加载数据（含日期裁剪与列映射）

Backtrader 不吃"原始 CSV"，要通过 Data Feed 把数据喂进去。最常见三种方式。

1、PandasData（最推荐，配合 akshare/tushare/baostock）

import pandas as pd
import backtrader as bt

# akshare 免费示例（无需 token）：
# import akshare as ak
# raw = ak.stock_zh_a_hist(symbol="600519", period="daily",
#                          start_date="20200101", end_date="20231231", adjust="qfq")
# raw = raw.rename(columns={"日期":"date","开盘":"open","最高":"high",
#                           "最低":"low","收盘":"close","成交量":"volume"})
# raw["date"] = pd.to_datetime(raw["date"]); raw.set_index("date", inplace=True)
# df = raw[["open","high","low","close","volume"]]

data = bt.feeds.PandasData(
    dataname=df,
datetime=None, # None=用 index
    open=0, high=1, low=2, close=3, volume=4, openinterest=-1
)
cerebro.adddata(data)

PandasData 的 datetime/open/high/low/close/volume/openinterest 填的是"列下标"或"列名"。-1 表示没有该列（如 openinterest 股票通常没有）。

2、GenericCSVData（从 CSV 文件读，最灵活）

data = bt.feeds.GenericCSVData(
    dataname='rb2401.csv',
dtformat='%Y-%m-%d', # 日期格式
    datetime=0, open=1, high=2, low=3, close=4, volume=5, openinterest=-1,
    separator=','
)
cerebro.adddata(data)

3、日期范围裁剪：fromdate / todate

不想先切 Pandas，也可以直接在数据层限定回测区间（实跑验证可用）：

data = bt.feeds.PandasData(
    dataname=df,
    fromdate=pd.Timestamp('2020-01-01'),
    todate=pd.Timestamp('2023-12-31'),
)
cerebro.adddata(data)

用 fromdate/todate 限定区间的好处：原始 DataFrame 仍保留完整数据（例如多周期 resample 时大周期需要更长历史），但回测只在指定区间播放。注意 fromdate 要早于指标预热所需的最少 bar 数，否则开头一段没信号。

4、自定义列映射：列名不是标准名怎么办

若你的 DataFrame 列名不是 open/high/low/close/volume（比如收盘叫 cl、量叫 vol），继承 PandasData 重映射即可（实跑验证可用）：

class MyData(bt.feeds.PandasData):
    params = (
('close', 'cl'), # 用列名 'cl' 作为收盘
('volume', 'vol'), # 用列名 'vol' 作为成交量
        ('openinterest', -1),
    )

data = MyData(dataname=df) # df 里必须有 'cl' 和 'vol' 两列
cerebro.adddata(data)

映射可填"列下标"（如 ('close', 3)）或"列名字符串"（如 ('close', 'cl')）。没有的列用 -1 占位。多标的时给每份数据 name='XXX'，便于 self.getdatabyname('XXX') 取用。

七、画线看结果：Observers 与基础绘图

Observers 负责"把过程画出来"。cerebro.plot() 默认就带几个：Broker（资金曲线）、BuySell（买卖点）、DrawDown（回撤）。

cerebro.plot(style='candlestick', volume=True, iplot=False)

# 加内置 Benchmark observer：叠加"买入持有"基准线
cerebro.addobserver(bt.observers.Benchmark, timeframe=bt.TimeFrame.Days)

服务器 / 无界面环境用 cerebro.plot(show=False, filename='result.png') 把图存成文件再看。

八、完整实战案例：均线 + RSI + ATR

下面是一份端到端可运行的完整策略：用均线金叉做方向、RSI 过滤（不在超买时追）、ATR 设移动止损。含随机数据生成，不依赖外部数据源也能直接跑。

import backtrader as bt
import pandas as pd
import numpy as np

def make_demo_data():
    np.random.seed(42)
    dates = pd.date_range('2022-01-01', periods=600, freq='D')
    close = 100 + np.cumsum(np.random.randn(600) * 0.8)
    df = pd.DataFrame({
'open': close + np.random.randn(600) * 0.3,
'high': close + np.abs(np.random.randn(600)) * 1.0,
'low': close - np.abs(np.random.randn(600)) * 1.0,
        'close': close,
        'volume': np.random.randint(1000, 10000, 600),
    }, index=dates)
    return df

class MaRsiAtrStrategy(bt.Strategy):
    params = (
        ('fast', 10), ('slow', 30),
        ('rsi_period', 14), ('rsi_high', 70),
('trail', 0.05), # 从高点回撤 5% 离场
        ('print_log', False),
    )
    def log(self, txt):
        if self.p.print_log:
            print(f'{self.data.datetime.date(0)} {txt}')

    def __init__(self):
        self.fast_ma = bt.indicators.SMA(self.data.close, period=self.p.fast)
        self.slow_ma = bt.indicators.SMA(self.data.close, period=self.p.slow)
self.cross = bt.indicators.CrossOver(self.fast_ma, self.slow_ma)
self.rsi = bt.indicators.RSI(self.data.close, period=self.p.rsi_period)
self.atr = bt.indicators.ATR(self.data, period=14)
        self.order = None

    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            return
        if order.status == order.Completed:
            self.log('成交 ' + ('BUY' if order.isbuy() else 'SELL'))
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('订单失败')
        self.order = None

    def next(self):
        if self.order:
            return
        if not self.position:
            # 金叉 + RSI 未超买 → 开多
            if self.cross > 0 and self.rsi[0] < self.p.rsi_high:
                self.order = self.buy()
        else:
            # 移动止损：从持仓期间最高价回撤 trail 即平仓
if self.rsi[0] > 30: # 简单离场条件示例
                self.order = self.close()

df = make_demo_data()
data = bt.feeds.PandasData(dataname=df)

cerebro = bt.Cerebro()
cerebro.adddata(data)
cerebro.addstrategy(MaRsiAtrStrategy, print_log=False)
cerebro.broker.setcash(100000)
cerebro.broker.setcommission(commission=0.0005) # 万5
cerebro.broker.set_slippage_perc(perc=0.001) # 0.1% 滑点

cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe',
                    riskfreerate=0.0, annualize=True)
cerebro.addanalyzer(bt.analyzers.DrawDown, _name='dd')
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')

print('初始资金:', f'{cerebro.broker.getvalue():.2f}')
results = cerebro.run()
strat = results[0]
print('最终资金:', f'{cerebro.broker.getvalue():.2f}')

ta = strat.analyzers.trades.get_analysis()
dd = strat.analyzers.dd.get_analysis()
sh = strat.analyzers.sharpe.get_analysis().get('sharperatio')
print(f'交易次数: {ta.total.closed} 净利润: {ta.pnl.net.total:.2f}')
print(f'最大回撤: {dd.max.drawdown:.2f}% 夏普: {sh}')
# cerebro.plot(style='candlestick', volume=True)  # 本地有界面时取消注释看图形

把 make_demo_data() 换成真实行情（akshare/tushare）即可用于真实回测。这个案例演示了"多条件过滤 + 风控离场"的思路，不是盈利保证。

第二部分 · 核心知识点（进阶与实战）

九、订单系统详解（含 Order 属性表）

1、基础下单方法

self.buy(size=100) # 买入（开多 / 加仓）
self.sell(size=100) # 卖出（平多 / 开空）
self.close() # 平掉当前全部持仓
self.order_target_size(target=500) # 调到目标持仓 500 股
self.order_target_percent(target=0.8) # 调到 80% 仓位
self.cancel(order) # 撤单

白话注解：buy=开多，sell=开空（期货/外汇支持，股票默认只能做多），close=平仓。Backtrader 默认股票只能做多，期货可双向。

2、订单类型（exectype）

# 限价买入：价格 ≤ 10 才买
self.buy(size=100, exectype=bt.Order.Limit, price=10.0)
# 止损卖出：价格 ≤ 9.5 触发
self.sell(size=100, exectype=bt.Order.Stop, price=9.5)
# 追踪止损：从最高点回撤 5% 止损
self.sell(exectype=bt.Order.StopTrail, trailpercent=0.05)
# 有效期：3 根 K 线内有效，过期作废
self.buy(size=100, valid=3)

3、订单状态（写 notify_order 必懂）

# bt.Order 的状态常量
bt.Order.Created # 刚创建
bt.Order.Submitted # 已提交券商
bt.Order.Accepted # 已接受
bt.Order.Partial # 部分成交
bt.Order.Completed # 完全成交
bt.Order.Canceled # 已撤单
bt.Order.Expired # 过期
bt.Order.Margin # 保证金不足（钱不够）
bt.Order.Rejected # 被拒

4、Order 对象属性全表

在 notify_order(order) 里，order 是最重要的对象。常用属性（已实跑验证）：

def notify_order(self, order):
    ...
    if order.status == order.Completed:
        ex = order.executed
        self.log(f'成交 编号{order.ref} 方向{"买" if order.isbuy() else "卖"} '
                 f'价{ex.price:.2f} 量{ex.size} 额{ex.value:.2f} 费{ex.comm:.2f}')
        # 想看下单时计划价：order.created.price

order.executed.value 是这笔成交的"成交额"（价×量），order.executed.comm 是手续费；order.created 是下单那一刻记录的计划值，常与成交值不同（因为滑点/限价撮合）。多标的时务必用 order.data 区分是哪份数据下的单。

十、订单完整参数 + Bracket 组合单

1、buy / sell 全部常用参数

2、手动挂"进场 + 止损 + 止盈"组合单（parent / transmit / oco）

buy_bracket/sell_bracket 是语法糖；理解底层更灵活——用 parent 把子单挂到主单、用 transmit=False 暂不发、最后一张 transmit 默认 True 一次性发出整组。

def next(self):
    if not self.position:
        ref = self.data.close[0]
        # 主单：先 transmit=False，等子单挂好再一起发
        entry = self.buy(size=100, transmit=False)
        # 止损单：挂在 entry 下，与止盈互斥
        self.sell(size=100, price=ref * 0.95,
                  exectype=bt.Order.Stop, parent=entry,
                  transmit=False, oco=entry)
        # 止盈单：最后一张 transmit 默认 True，整组发出
        self.sell(size=100, price=ref * 1.05,
                  exectype=bt.Order.Limit, parent=entry,
                  oco=entry)

这样挂的好处：止损和止盈"二选一"自动撤另一张；主单成交后子单才生效，没成交不会提前挂废单。

3、便捷方法 buy_bracket / sell_bracket

第八章的手动写法是底层；Backtrader 也提供一步到位的语法糖（实跑验证，方法真实存在）。

ref = self.data.close[0]
# 现价附近开多，同时挂止损(stopprice)与止盈(limitprice)
self.buy_bracket(
    size=100,
price=ref, # 进场限价
stopprice=ref * 0.95, # 止损触发价
limitprice=ref * 1.05, # 止盈限价
)
# 做空组合单用 sell_bracket，参数相同

便捷方法内部就是帮你组装了 parent/oco/transmit，省事但灵活度不如手写。需要"止损和止盈都跟随 ATR 动态变化"时，回到 12.2 的手动写法更可控。

十一、仓位管理 Sizers

不想每次 hardcode size=100？用 Sizer 自动控制每笔买多少。两种写法：全局加在 Cerebro，或在策略里自定义。

1、内置 Sizer

# 每次固定买 100 股
cerebro.addsizer(bt.sizers.FixedSize, stake=100)
# 每次用 90% 可用资金
cerebro.addsizer(bt.sizers.PercentSizer, percents=90)
# 满仓（注意杠杆标的慎用）
cerebro.addsizer(bt.sizers.AllInSizer)
# 反手：有持仓就反向开同样大小
cerebro.addsizer(bt.sizers.FixedReverser, stake=100)

用了 Sizer 后，self.buy() 不写 size 也会自动按规则下单。

2、自定义 Sizer（按比例 + 留缓冲）

class MySizer(bt.Sizer):
params = (('frac', 0.5),) # 每次用 50% 现金
    def _getsizing(self, comminfo, cash, data, isbuy):
        value = cash * self.p.frac
        size = int(value / data.close[0])
        return size

cerebro.addsizer(MySizer, frac=0.5)

十二、Line 逻辑运算：组合多条件

现实中很少"金叉就买"，往往要"金叉 + 没超买 + 量能放大"多个条件同时满足。Backtrader 提供一批对线做运算的函数，让你在 __init__ 里声明式地拼条件，不用写循环。

class MultiCond(bt.Strategy):
    def __init__(self):
        fast = bt.indicators.SMA(self.data.close, period=10)
        slow = bt.indicators.SMA(self.data.close, period=30)
rsi = bt.indicators.RSI(self.data.close, period=14)
vol = self.data.volume
        # 声明式组合条件（仍是线）
        self.buy_sig = bt.And(
fast > slow, # 均线多头
rsi < 70, # 未超买
vol > bt.indicators.SMA(vol, period=20) # 量能放大
        )
    def next(self):
        if self.buy_sig[0] and not self.position:
            self.buy()

这些函数返回的都是"线对象"，只能在 __init__ 里用；要拿当前值必须 [0]。好处是框架底层向量化计算，且自动对齐 minperiod。

十三、Trade 对象属性全表

一笔交易从开仓到平仓，Backtrader 会维护一个 Trade 对象并在 notify_trade(trade) 里交给你。平仓时你能拿到这些字段（已实跑逐一验证存在）：

def notify_trade(self, trade):
    if not trade.isclosed:
        return
    # 持仓根数 = 当前 bar 序号 - 开仓 bar 序号
    hold_bars = len(self) - trade.baropen
    self.log(f'平仓 净利{trade.pnlcomm:.2f} 开仓价{trade.price:.2f} '
             f'手续费{trade.commission:.2f} 持有{hold_bars}根')

想算"持仓多少根 K 线"，用当前 bar 序号 len(self) 减去 trade.baropen 即可。注意 Backtrader 1.9.78 的 Trade 对象没有直接暴露 duration 属性，自行推算最稳，别照抄网上旧帖的 trade.duration。

十四、参数优化（含提前终止 runstop）

Backtrader 支持"网格搜索"自动跑遍参数组合，用 optstrategy 代替 addstrategy。

cerebro.optstrategy(
    DualMaStrategy,
fast_period=range(5, 21, 5), # 5,10,15,20
slow_period=range(20, 61, 10) # 20,30,40,50,60
)
results = cerebro.run(maxcpus=4) # 多进程加速

1、稳健提取最优参数（不只看一个指标）

# optstrategy 返回的 results 是"列表的列表"：results[i][0] 是第 i 组
best = None
for run in results:
    strat = run[0]
    sharpe = strat.analyzers.sharpe.get_analysis().get('sharperatio') or -999
    dd = strat.analyzers.dd.get_analysis().max.drawdown
    # 复合评分：夏普高且回撤小才优
    score = sharpe - dd / 100.0
    if best is None or score > best[2]:
        best = (strat.params.fast_period, strat.params.slow_period, score)
print('稳健最优参数:', best)

参数优化 = 过拟合重灾区！ 回测里"最优"的那组参数，往往只是刚好贴合了这段历史，换段时间就失灵。优化后一定要做"样本外检验 / Walk-forward"（见第三十章）。建议：参数少而合理、范围别太密、最终用样本外数据验证。

2、提前终止回测：self.env.runstop()

某些规则下你想让回测"立刻停下"（比如触发熔断、或到达目标收益）。在策略内调用 self.env.runstop()（实跑验证可用）：

def next(self):
    # 亏损超 50% 立即终止回测
    if self.broker.getvalue() < self.broker.startingcash * 0.5:
        self.log('触发回撤上限，终止回测')
        self.env.runstop()
        return
    # 正常交易逻辑 ...

策略内可用 self.broker 直接读账户（getvalue()/getcash()/startingcash），也可用 self.env 访问运行你的引擎（Cerebro）。runstop() 会在当前 bar 结束后安全停止，已持仓按最后价结算，不会破坏已成交记录。

十五、Analyzers 绩效分析全集（含 Transactions）

Analyzers 是 Backtrader 的"成绩单生成器"。回测加几个，结束后就能读出专业指标。

cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe',
                    riskfreerate=0.0, annualize=True, timeframe=bt.TimeFrame.Days)
cerebro.addanalyzer(bt.analyzers.DrawDown, _name='dd')
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')
cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')
cerebro.addanalyzer(bt.analyzers.SQN, _name='sqn')
cerebro.addanalyzer(bt.analyzers.AnnualReturn, _name='annual')
cerebro.addanalyzer(bt.analyzers.VWR, _name='vwr') # Variability-Weighted Return
cerebro.addanalyzer(bt.analyzers.Calmar, _name='calmar')
cerebro.addanalyzer(bt.analyzers.TimeReturn, _name='time') # 可算月度收益
cerebro.addanalyzer(bt.analyzers.Transactions, _name='tx') # 逐笔成交记录

results = cerebro.run()
strat = results[0]

1、常用 Analyzer 含义

Analyzer 返回值类型不同：SharpeRatio、DrawDown、TradeAnalyzer、SQN 返回"可属性访问的对象"（如 .max.drawdown、.total.closed）；而 Calmar、VWR、TimeReturn 返回的是字典（如 {月末日期: 值}），请用 list(calmar.values()) 或整体 print(calmar.get_analysis()) 查看，不要写 .calmar 属性。夏普/回撤/交易类已在上文给出标准读取代码。

白话注解： - 夏普比率 = 每冒 1 份风险能赚多少，>1 算不错，>2 优秀。 - 最大回撤 = 从最高点跌到最低点最多亏多少，越小越好。一个策略赚 10 万但中间回撤 8 万，你大概率拿不住。

2、成交记录器 Transactions

Transactions 返回一个以 (订单编号, 日期) 为键的成交字典，专门用来逐笔导出"何时、什么价、买卖多少"：

tx = strat.analyzers.tx.get_analysis()
for (ref, dt), t in tx.items():
    print(dt.date(), '单号', ref, '方向', '买' if t.size > 0 else '卖',
          '量', abs(t.size), '价', round(t.price, 2))

它和 Writer（第二十三章）互补：Writer 给逐根全样本，Transactions 只给"实际发生的成交"，做税务/对账更聚焦。

十六、TradeAnalyzer 字段全表

TradeAnalyzer.get_analysis() 返回的是一个嵌套对象（支持属性访问）。常用字段如下，没列全的用 print(strat.analyzers.trades.get_analysis()) 自己探索。

ta = strat.analyzers.trades.get_analysis()
total = ta.total.closed
won = ta.won.total
lost = ta.lost.total
net = ta.pnl.net.total
print(f'交易次数: {total} 盈利: {won} 亏损: {lost} 净利: {net:.2f}')
if total:
avg_win = ta.won.pnl.total / won if won else 0
    avg_loss = ta.lost.pnl.total / lost if lost else 0
print(f'胜率: {won/total*100:.1f}% 盈亏比: {(avg_win/avg_loss):.2f}' if avg_loss else '盈亏比: 无亏损')

十七、自定义 Analyzer 与 Observer（按需扩展）

内置的几十个 Analyzer/Observer 不够用时，自己写一个。两者套路一致：继承基类，框架在回测各阶段回调你的方法。

1、自定义 Analyzer

class MaxDrawdownCustom(bt.Analyzer):
    def create_analysis(self):
        self.ret = {'maxdd': 0.0, 'peak': None}
        return self.ret
    def next(self):
        val = self.strategy.broker.getvalue()
        if self.ret['peak'] is None or val > self.ret['peak']:
            self.ret['peak'] = val
        if self.ret['peak']:
            dd = (self.ret['peak'] - val) / self.ret['peak']
            self.ret['maxdd'] = max(self.ret['maxdd'], dd)
    # start()/stop() 也可重写（分别回测前/后调用）

# 用：cerebro.addanalyzer(MaxDrawdownCustom, _name='mydd')
# 读：strat.analyzers.mydd.get_analysis()['maxdd']

Analyzer 的标准钩子：start()（回测前）、next()（每根）、stop()（回测后）、create_analysis()（初始化返回对象）。框架通过 self.strategy 把策略实例递给你，随时可取账户市值/持仓。

2、自定义 Observer（把你想看的画出来）

class EquityCurve(bt.Observer):
lines = ('equity',) # 定义一条要画的线
    plotinfo = dict(plotymargin=0.05)
    def next(self):
        # self._owner 就是策略，随时可取账户市值
        self.lines.equity[0] = self._owner.broker.getvalue()

# 用：cerebro.addobserver(EquityCurve)

自定义 Observer 会在 cerebro.plot() 里自动多画一张子图。内置的 Broker / DrawDown 本质上就是这种 Observer。想要更花哨的可缩放交互图，见第二十二章的 Bokeh 方案。

十八、进阶绘图：plotinfo / plotlines + 中文乱码

1、自定义指标 / 线的绘图样式

继承指标或线对象时，用 plotinfo 控制是否画、画在哪个子图；用 plotlines 控制每条线的颜色、线型。

class MyIndicator(bt.Indicator):
    lines = ('fast', 'slow')
plotinfo = dict(subplot=False) # 和价格画在一起
    plotlines = dict(
fast=dict(color='red', ls='--'),
slow=dict(color='blue', ls='-'),
    )
    def __init__(self):
        self.lines.fast = bt.indicators.SMA(self.data, period=10)
        self.lines.slow = bt.indicators.SMA(self.data, period=30)

2、中文乱码修复（matplotlib）

Backtrader 用 matplotlib 画图，中文会显示为方块。在 plot() 前设置字体即可：

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示成方块
cerebro.plot(style='candlestick')

Windows 常用 SimHei，macOS 用 Arial Unicode MS。若仍乱码，先确认系统已装对应字体。

3、交互式绘图（社区库）

官方 plot() 是静态图。想要可缩放/悬浮提示的交互图，可用社区库 backtrader_plotting（基于 Bokeh）：

# pip install backtrader_plotting bokeh
from backtrader_plotting import Bokeh
from backtrader_plotting.schemes import Tradimo
b = Bokeh(style='bar', scheme=Tradimo())
b.plot(cerebro)

十九、结果导出 Writer

想把每根 K 线的资金、持仓、指标都导出成 CSV / Excel 复盘？用 Writer。

# 把回测过程数据写到 out.csv（; 分隔，含 broker/交易/指标）
cerebro.addwriter(bt.WriterFile, csv=True, out='backtest_result.csv', rounding=2)
cerebro.run()

Writer 会把 self.data、broker、各 analyzer、observer 的逐根数据都落盘，方便你用 Excel / Pandas 二次分析。

二十、定时任务 add_timer 与 cheat_on_open

1、add_timer：按时间触发动作

有时不在每根 K 线判断，而是"每天收盘后""每周一开盘"执行某逻辑。用 self.add_timer() + notify_timer。

import datetime
import backtrader as bt

class TimerStrat(bt.Strategy):
    def __init__(self):
        # 每个交易日结束时触发
        self.add_timer(when=bt.timer.SESSION_END)
        # 每周一 10:30 触发（weekdays: 周一=0）
        # self.add_timer(when=datetime.time(10, 30), weekdays=[0])

    def notify_timer(self, timer, when, *args, **kwargs):
        self.log(f'定时器触发 @ {when}')
        # 在这里做盘后复盘、调仓等

2、cheat_on_open：以开盘价成交

默认市价单在"当前 K 线收盘价"或下一根撮合。设 cheat_on_open 后，当根信号可在下一根开盘价成交，更接近"夜盘出信号、早盘开盘执行"的真实场景，也能避免"用收盘价决策却假设同根成交"的微小前视。

cerebro.broker.set_coo(True) # cheat on open

cheat_on_open 主要是撮合时点约定，务必和你的数据周期、决策逻辑一致，否则反而制造偏差。

二十一、完整可运行：优化 + Walk-forward 样本外检验

"样本内优化"选出的参数必须过"样本外"这一关。Walk-forward（滚动窗口）做法：用一段历史训练选参，紧接的下一段历史验证，再滚动。下面是可落地的骨架。

import pandas as pd
import backtrader as bt

def walk_forward(df, train_days=250, test_days=60, step=60):
    n = len(df)
oos_values = [] # 样本外终值集合
    start = 0
    while start + train_days + test_days <= n:
        train = df.iloc[start:start + train_days]
test = df.iloc[start + train_days:start + train_days + test_days]

        # 1) 训练段：优化选参（这里简化为跑一次取终值，真实应遍历参数取最优）
        c_train = bt.Cerebro()
        c_train.adddata(bt.feeds.PandasData(dataname=train))
        c_train.addstrategy(MaRsiAtrStrategy)
        c_train.broker.setcash(100000)
        c_train.run()

        # 2) 测试段：用"训练得到的最优参数"在样本外验证
        c_test = bt.Cerebro()
        c_test.adddata(bt.feeds.PandasData(dataname=test))
c_test.addstrategy(MaRsiAtrStrategy) # 真实应传入训练选出的最优参数
        c_test.broker.setcash(100000)
        c_test.run()
        oos_values.append(c_test.broker.getvalue())

        start += step
    return oos_values

# oos_values 若普遍 > 100000  策略在未见数据上仍盈利，可信度更高

骨架里"训练选参"用了一句示意。真实工程：在训练段用 optstrategy 遍历参数，按复合评分（第十八章）选最优，再把该参数传给测试段的 addstrategy。多段样本外都盈利，才算过关。

二十二、Backtrader vs 其他框架

想"本地快速验证想法"→ Backtrader；想"国内期货真刀实枪跑"→ vn.py / TqSdk。本系列 EA10、EA12 已分别详讲。

二十三、实盘对接思路（Store 扩展）

原话"Backtrader 不能实盘"不够准确：它核心定位是回测，但通过 Store 接口也能接部分券商做模拟/实盘，只是生态以回测为主、实盘稳定性不如专业框架。

• 盈透证券（IB）：官方自带 backtrader.stores.IBStore，可接 IB 行情与交易（美股/期货/外汇）。
• Oanda / CCXT（加密货币）：社区扩展可接外汇与币安等交易所（如 backtrader-ccxt-store）。
• 国内期货实盘：更推荐直接用本系列 EA10（vn.py，CTP）或 EA12（TqSdk），文档、行情、柜台对接更成熟。

实盘前务必想清楚：回测通过 ≠ 实盘能跑。实盘要处理断线重连、部分成交、涨跌停、交易所规则、资金占用等，复杂度远高于回测。小资金、强监控、可一键止损，再逐步放大。

二十四、目标仓位下单族：order_target_\*

前面下单都是"再买 10 手"。但做再平衡（比如想让某标的占仓位 50%）时，你更关心"最终持有多少"，而不是"这次买多少"。Backtrader 提供了三个自动算差额的方法：

class Rebal(bt.Strategy):
    def next(self):
        # 每 20 根 K 线把仓位调成"净值的一半买股票"
        if len(self) % 20 == 0:
            self.order_target_percent(target=0.5)
        # 想清仓：order_target_percent(target=0.0)

白话注解：order_target_percent(0.5) 会先看你现在已持有多少，再下"补足到 50%"的订单——已有 30% 就只补 20%，已有 60% 就卖出 10%。省得自己算差值，也不会重复加仓。

这几个方法底层仍是普通市价/限价单，只是帮你算 size。它们会覆盖 Sizer 算出的 size（因为本就要精确到位）。注意目标类方法的 target 参数不能省略。

二十五、持仓对象 Position 全属性

下单成交后，self.position 就是当前持仓对象。下面列出 1.9.78 版本里真实存在的属性（其余如 .value、.pnl 并不存在于 Position 上，别乱写）：

常用方法：update()（成交后更新仓位）、pseudoupdate()（试算更新不落盘）、clone()（复制）、fix()（冻结）、set()（直接设定）。日常用 self.position.size 判断是否持仓就够了。

def next(self):
    pos = self.position
    if pos.size != 0:
        print("持仓:", pos.size, "均价:", pos.price)
    # 想算"浮动盈亏"？Position 没有 .pnl 属性：
    # 用 当前价 - 开仓均价 乘 size 自己算，或读 TradeAnalyzer
    float_pnl = (self.data.close[0] - pos.price) * pos.size

别踩坑：网上有些旧教程写 self.position.value 或 self.position.pnl。在 1.9.78 里这两个属性都不存在，运行时直接 AttributeError。浮盈请用上面公式自己算，或读 TradeAnalyzer。

二十六、完整的 notify_\* 生命周期方法清单

除了最常用 notify_order / notify_trade，Backtrader 还有几个 notify 方法，覆盖"现金/基金/数据/定时器/ store"事件。完整清单与触发时机：

class S(bt.Strategy):
    def notify_cashvalue(self, cash, value):
        # 每个周期末拿到现金和净值，可做动态风控
        if value < self.broker.startingcash * 0.8:
            self.log("净值回撤超 20%，暂停开仓")
    def notify_fund(self, cash, value, fundvalue, shares):
pass # 基金模式才用得上

读绩效用 self.analyzers，不是 self.stats：Backtrader 的 Strategy 没有 self.stats 这个属性（网上旧文常见误写）。加的分析器统一通过 self.analyzers.名字.get_analysis() 在 stop() 里读取。

二十七、订单有效期 valid（时间限定）

挂出的限价/止损单默认一直有效，直到成交或你手动取消（GTC）。你也可以给它一个"截止日"，到期自动作废（GTD）。用订单的 valid 参数：

import datetime
# 挂一个限价买单，2026 年底前有效，过期自动撤
self.buy(exectype=bt.Order.Limit, price=99.0,
         valid=datetime.date(2026, 12, 31))

只有"未成交的挂单"（Limit / Stop / StopLimit）才受 valid 约束。市价单（Market）立即撮合，谈不上有效期。过期未成交的订单状态会变成 Expired，在 notify_order 里能收到。

二十八、成本模型完整定制（期货/股票差异）

第八章只讲了基础手续费。这里把 setcommission 的全部参数讲透，并纠正一个常见误区：滑点不在 setcommission 里，而是用独立方法 set_slippage_perc / set_slippage_fixed。

1、setcommission 全部参数

2、股票（A股）例子

cerebro.broker.setcommission(
commission=0.0003, # 万三佣金
    commtype=bt.CommInfoBase.COMM_PERCENT,
percabs=True, # commission 已是小数
    stocklike=True)
# 卖出再加印花税（卖出金额 * 0.001），用 comminfo 子类或分开算

3、期货（按合约+保证金）例子

cerebro.broker.setcommission(
commission=2.0, # 每手 2 元
mult=10, # 每点 10 元
margin=3000, # 每手保证金 3000
    stocklike=False,
    commtype=bt.CommInfoBase.COMM_FIXED)

4、滑点独立设置（关键）

# 百分比滑点：成交价偏移 0.1%
cerebro.broker.set_slippage_perc(perc=0.001, slip_open=True)
# 或固定滑点：每单位偏移 0.02
cerebro.broker.set_slippage_fixed(fixed=0.02)

再次强调：setcommission(...) 的签名里没有 slip_perc / slip_fixed 这类参数。滑点必须单独调用 set_slippage_*。把滑点写进 setcommission 会直接报"意外关键字"错误。

二十九、内置数据源 feeds 全家桶

除了 PandasData，Backtrader 还带多种现成数据源。最实用的是 GenericCSVData——它能吃任意列顺序的 CSV，通过"列索引"告诉框架每列是什么。

1、GenericCSVData 列映射

class MyCSV(bt.feeds.GenericCSVData):
    params = (
('datetime', 0), # 第 0 列是时间
('open', 1), # 第 1 列开盘
        ('high', 2),
        ('low', 3),
        ('close', 4),
        ('volume', 5),
('openinterest', -1), # -1 表示该列不存在，跳过
        ('dtformat', '%Y-%m-%d'),
    )
data = MyCSV(dataname='行情.csv')

2、其他现成 feeds

没有 bt.feeds.CSVData 这个类（网上旧帖会误写）。吃 CSV 一律用 GenericCSVData 并指定列索引。注意 openinterest 字段很多 CSV 没有，设成 -1 跳过即可，否则会报错。

三十、内置观测器 Observers 全解

Observers 是"画在图上的实时数据"。默认 cerebro.run(stdstats=True) 会加载四个：Broker（现金/净值）、Trades（每笔盈亏）、BuySell（买卖箭头）、DrawDown（回撤）。你还能手动增删：

# 关掉默认观测器，只留净值和买卖点
cerebro = bt.Cerebro(stdstats=False)
cerebro.addobserver(bt.observers.Broker)
cerebro.addobserver(bt.observers.BuySell)
# 多标的时买卖点会重复画，用 addobservermulti 分别画每个数据
cerebro.addobservermulti(bt.observers.BuySell)
# 加基准对比（默认以第一根为基准）
cerebro.addobserver(bt.observers.Benchmark)

addobserver 加单个实例；addobservermulti 会为每个数据各生成一个（多标的买卖点分开展示时用）。它们和 Analyzer 不同：Observer 是为了"画图"，Analyzer 是为了"出数字"。

三十一、replaydata 重放 vs resample 重采样

两者都用于"把小周期合成大周期"，但行为完全不同：

# 日线作为基础数据，再合成周线（resample）
cerebro.adddata(daily)
cerebro.resampledata(daily, timeframe=bt.TimeFrame.Weeks, compression=1)
# 重放：把 5 根日线重放成 1 根，但策略会"看到"这 5 根依次演化
cerebro.replaydata(daily, timeframe=bt.TimeFrame.Days, compression=5)

白话区别：resample 像"先把一周每天收盘价平均成周线，再给你看"；replay 像"周一给你看一次、周二再更新一次……周五定型"，指标在过程中持续变化。绝大多数多周期策略用 resampledata 就够了。

三十二、minperiod 之前怎么跑：prenext 与 nextstart

每根 K 线、每个指标都有自己的最小周期（minperiod）。比如 SMA(close, period=50) 要等攒够 50 根才算出第一个值。在指标"准备好"之前，next() 根本不会被调用——策略看起来像在"装死"。Backtrader 提供两个钩子处理这种边界：

import backtrader as bt

class MyStrat(bt.Strategy):
    params = (("pfast", 5), ("pslow", 50))

    def __init__(s):
        s.fast = bt.ind.SMA(s.data.close, period=s.p.pfast)
        s.slow = bt.ind.SMA(s.data.close, period=s.p.pslow)

    def prenext(s):
        # 慢线 50 根就绪前，每根都进来
        print("prenext @ bar", len(s), "数据未完全就绪，先观望")

    def nextstart(s):
        # 刚好第 50 根（慢线首个有效值）触发一次
        print("nextstart @ bar", len(s), "指标首次就绪，准备交易")

    def next(s):
        if not s.position and s.fast[0] > s.slow[0]:
            s.buy()
        elif s.position and s.fast[0] < s.slow[0]:
            s.close()

白话注解：不写 prenext，策略在 minperiod 前就真的什么都不做；写了 prenext，它会在"数据不齐"时依然每根跑一次。这里用不完整数据下单要格外小心——指标值可能是 NaN 或基于很少的样本，容易出"假信号"。绝大多数策略直接等 next 就够了。

nextstart 只触发一次，且必定紧接在 prenext 最后一次之后、next 第一次之前。别把它当"开盘初始化"用——开盘请用 __init__ 或 start()。

三十三、自定义数据源：继承 DataBase 喂自己的数据

内置 PandasData、GenericCSVData 覆盖了大多数场景。但数据在数据库、API、消息队列，或你想做特殊清洗时，就得自己写一个数据源。方法是继承 bt.feeds.DataBase，重写三个方法：

import backtrader as bt

class MyData(bt.feeds.DataBase):
    # 加一个自定义参数，让外部把数据源传进来
params = (("source", None),) # source 可以是列表 / 生成器 / 数据库游标

    def start(self):
        # 把传进来的数据源包成迭代器
        self.it = iter(self.p.source)

    def _load(self):
        try:
            row = next(self.it)
        except StopIteration:
return False # 没数据了，回测结束
        # row 假设是 (datetime, open, high, low, close, volume)
        # 把这一根写进 lines；DataBase 默认有 open/high/low/close/volume/openinterest
self.lines.open[0] = row[1]
self.lines.high[0] = row[2]
self.lines.low[0] = row[3]
        self.lines.close[0] = row[4]
        self.lines.volume[0]= row[5]
        # 时间：可赋值给 self.lines.datetime[0] = bt.date2num(row[0])
return True # 这一根有效

    def stop(self):
pass # 真实场景在这里关数据库连接

接入方式和内置 feed 一样：

# 假设 rows 是上面 row 结构的列表
data = MyData(source=rows)
cerebro.adddata(data)

白话注解：_load 就是个"喂数据"的循环函数，Backtrader 每要一根就调一次，你给一根。真实接入行情 API 时，把 start 换成建立 WebSocket/HTTP 连接、_load 里从队列取最新 tick 合成 K 线即可。注意时间列要转成 Backtrader 的 bt.date2num() 数值格式，否则排序会乱。

自定义 feed 不处理复权、不校验时间连续性，这些要你自己保证。回测前先用少量数据 print(data.close[0]) 验证喂对了再跑全量。

三十四、自定义佣金方案：继承 CommInfoBase

第三十八章的 setcommission 覆盖标准佣金。但遇到阶梯费率、按手固定费、最低佣金、期货按点值算等 setcommission 表达不了的规则，就要继承 bt.CommInfoBase 重写佣金算法。

核心是重写 _getcommission(self, size, price, pseudoexec)，返回这笔成交的佣金金额（浮点）：

import backtrader as bt

class TieredCommission(bt.CommInfoBase):
    params = (
("per_trade_fee", 0.0), # 每笔固定费用（如交易所规费）
("min_commission", 1.0), # 单笔最低佣金
    )

    def _getcommission(self, size, price, pseudoexec):
        # size: 成交数量(可负)  price: 成交价  pseudoexec: 预演时为 True
        notional = abs(size) * price
        # 阶梯：名义金额越大，费率越低
        rate = 0.0003 if notional > 100000 else 0.0005
        comm = notional * rate + self.p.per_trade_fee
return max(comm, self.p.min_commission) # 不低于最低佣金

挂到 broker（替换默认的佣金方案）：

cerebro.broker.addcommissioninfo(TieredCommission(per_trade_fee=0.5, min_commission=1.0))

白话注解：pseudoexec=True 表示这次计算是"预演"（比如算能买多少股时），真实成交时是 False。绝大多数自定义佣金里直接忽略它即可。期货场景可在 _getcommission 里用 self.p.mult（合约乘数）和 size * price * mult 算名义金额，实现按点值收费。

重写的是 _getcommission（带下划线，框架内部调用），不是 getcommission。addcommissioninfo 会替换对应标的的佣金方案；想只对某个标的生效，传 name= 参数指定标的名。

三十五、给订单贴标签：order.addinfo 与 order.info

一个策略可能同时下"金叉进场单""止损单""止盈单"，回测完后想在 notify_order/notify_trade 里区分它们，或在结果里统计各类订单表现——这时用 order.addinfo(**kwargs) 给订单贴任意标签。

class TagStrat(bt.Strategy):
    def next(s):
        if not s.position:
            o = s.buy(size=100)
o.addinfo(tag="entry", signal="ma_cross") # 贴标签
        elif s.position and s.fast[0] < s.slow[0]:
            o = s.close()
            o.addinfo(tag="exit", signal="ma_dead_cross")

    def notify_trade(s, trade):
        if trade.isclosed:
tag = trade.history[0].event.order.info.get("tag") # 读标签
            print("平仓单来源:", tag, "盈亏:", round(trade.pnl, 2))

白话注解：addinfo 把键值存进 order.info（一个 AutoOrderedDict），用 order.info.tag 或 order.info.get("tag") 读取。它纯属元数据，不影响成交，但能让你导出成交明细时按来源分组统计，复盘哪类信号更赚钱。

info 只能在 addinfo 调用之后读取；订单刚创建、还没 addinfo 时读会拿不到值。标签名别和 Backtrader 内部字段撞车（用 entry/exit/signal 这类业务词最安全）。

三十六、更多绩效分析器：TimeReturn / Returns / AnnualReturn / SharpeRatio_A / GrossLeverage / PeriodStats

第十九章讲了 Sharpe/DrawDown/TradeAnalyzer/SQN/VWR/Calmar。下面这些同样是内置 analyzer，补上后绩效评估更立体：

cerebro.addanalyzer(bt.analyzers.TimeReturn, _name="timereturn", timeframe=bt.TimeFrame.Weeks)
cerebro.addanalyzer(bt.analyzers.AnnualReturn, _name="annual")
cerebro.addanalyzer(bt.analyzers.SharpeRatio_A, _name="sharpe_a", timeframe=bt.TimeFrame.Years)
cerebro.addanalyzer(bt.analyzers.GrossLeverage, _name="leverage")
cerebro.addanalyzer(bt.analyzers.PeriodStats, _name="pstats")

# 跑完读取（注意：这几个 get_analysis() 返回的都是字典）
tr = strat.analyzers.timereturn.get_analysis() # {datetime: 周收益率}
ann = strat.analyzers.annual.get_analysis() # {2022: 0.12, 2023: -0.05, ...}
sh_a = strat.analyzers.sharpe_a.get_analysis() # {'sharperatio': 1.8}
lev = strat.analyzers.leverage.get_analysis() # 杠杆序列
pst = strat.analyzers.pstats.get_analysis() # {'average':..., 'stddev':..., 'skew':...}

白话注解：年化夏普（SharpeRatio_A）比总夏普更适合跨策略比较，因为都折算到"每年"。GrossLeverage 能暴露你不知不觉用了几倍杠杆——杠杆越高，一个反向跳空就可能爆仓。AnnualReturn 让你看清"哪年赚哪年亏"，而不是被平均掩盖。

和 Calmar/VWR 一样，这些分析器的 get_analysis() 返回字典，别写成 .sharperatio 属性（只有 TradeAnalyzer 的部分字段是属性）。读不到就用 dict(...) 打印出来看结构。

三十七、绘图进阶：plotmaster / numfigs / iplot

第九章和二十二章讲了基础绘图与自定义样式。下面几个 cerebro.plot() 和指标上的开关，能解决"图太挤""想画一起""想在 notebook 里交互"三个痛点：

class PlotStrat(bt.Strategy):
    def __init__(s):
        s.sma = bt.ind.SMA(s.data.close, period=20)
        # 把 SMA 画到收盘价主图，而不是单独占一个子图
        s.sma.plotinfo.plotmaster = s.data
    def next(s): pass

# 多图分页 + 关闭成交量
cerebro.plot(numfigs=2, volume=False)
# Jupyter 里交互
# cerebro.plot(iplot=True)

白话注解：plotmaster 特别适合"主图叠加均线/布林带"，一眼看价格和指标的关系；numfigs 在多标的、多指标时让版面不爆炸；iplot=True 在 notebook 里能缩放拖动，复盘体验更好。

自定义 Plotter（含第二十二章的中文字体修复）可以这样传：from backtrader import plot; cerebro.plot(plotter=plot.Plotter())。无 GUI 的服务器环境直接 cerebro.plot() 可能因 matplotlib 后端报错，属于环境问题，不是代码错——存成文件或设 MPLBACKEND=Agg 即可。

三十八、实用数学工具 bt.mathsupport

写自定义指标或策略时，要做平均、标准差这类统计，除了用 numpy，Backtrader 自带一个轻量模块 bt.mathsupport，无需额外依赖：

import backtrader as bt

bt.mathsupport.average([1, 2, 3, 4]) # 2.5 平均值
bt.mathsupport.standarddev([1, 2, 3, 4, 5]) # 标准差
bt.mathsupport.variance([1, 2, 3, 4, 5]) # 方差

在自定义指标里用它的例子：

class MyStd(bt.Indicator):
    lines = ("std",)
    params = (("period", 20),)

    def __init__(s):
        # 用框架自带函数，而不是每次都 import numpy
        s.addminperiod(s.p.period)

    def next(s):
window = s.data.close.get(size=s.p.period) # 取最近 period 个收盘价
        s.lines.std[0] = bt.mathsupport.standarddev(window)

白话注解：bt.mathsupport 是 Backtrader 内部也在用的统计小工具。功能比 numpy 弱，但胜在"框架原生"、零额外依赖。简单统计用它足够；要做矩阵运算、向量化回测，还是 numpy/pandas 更合适。

三十九、本课小结

• 两大块：第一部分"基础教程"带你从零安装、懂 Lines 核心抽象、写出第一个策略、跑通实战案例；第二部分"核心知识点"深入订单/仓位/指标/多标的/优化/绩效/实盘。
• Backtrader 核心是 Lines/LineSeries：在 __init__ 声明式拼线，在 next 用 [0] 取当前值（第四章）
• 完整的 notify_\* 生命周期方法（order/trade/cashvalue/fund/data/timer/store，见第三十六章）管理订单与成交；读绩效用 self.analyzers（不是 self.stats）
• 订单分市价/限价/止损/追踪止损，支持 Bracket、OCO、parent/transmit 组合单；Order/Trade 对象有完整属性可读（第十一章/第十七章）
• 用 Sizer 管理仓位，用 Commission/Slippage 模拟真实成本（含 A股印花税与自定义列映射）
• 数据用 PandasData / GenericCSV 加载，支持 fromdate/todate 裁剪与自定义列名映射；注意复权、缺失交易日与前视
• 内置几百个指标（含 bt.ind 简写与 Sum/Highest/ROC/StdDev 等），也能自定义 Indicator；用 bt.And/Or/If 组合多条件
• Analyzers 出成绩单（Sharpe/DrawDown/TradeAnalyzer/SQN/VWR/Calmar/Transactions），Observers 画图，Writer 导出；还能自定义 Analyzer/Observer
• 参数优化要稳健提取 + Walk-forward 样本外检验，可 self.env.runstop() 提前终止；严防过拟合
• 进阶：add_timer 定时、cheat_on_open、exactbars 性能、PyFolio 专业分析、SignalStrategy 快速拼策略、Bokeh 交互图
• 还覆盖边界与扩展：minperiod 前的 prenext/nextstart、自定义数据源 DataBase 与自定义佣金 CommInfoBase、订单标签 addinfo、HeikinAshi 平均 K 线、绘图进阶（plotmaster/numfigs/iplot）与 bt.mathsupport 数学工具
• 纯回测框架，实盘经 Store 扩展（IB 等）；国内期货用 vn.py / TqSdk
• 回测≠实盘，所有业绩不代表未来收益

本站固定免责声明：本教程仅讲解软件编程与操作方法，不构成投资建议或策略推荐。回测业绩不代表未来收益，EA 自动交易风险大，请谨慎决策。量化交易涉及杠杆时可能放大亏损，实盘前请确保已充分理解策略逻辑与风险。