The Definitive backtrader Cheatsheet

pip install backtrader
# For plotting capabilities
pip install backtrader[plotting]

import backtrader as bt
import datetime

# 1. Create a Strategy class
class MyFirstStrategy(bt.Strategy):
    def __init__(self):
        self.dataclose = self.datas[0].close

    def log(self, txt, dt=None):
        dt = dt or self.datas[0].datetime.date(0)
        print(f'{dt.isoformat()}, {txt}')

    def next(self):
        self.log(f'Close, {self.dataclose[0]:.2f}')

# 2. Instantiate the Cerebro engine
cerebro = bt.Cerebro()

# 3. Add the Strategy to Cerebro
cerebro.addstrategy(MyFirstStrategy)

# 4. Create and Add a Data Feed
data = bt.feeds.GenericCSVData(
    dataname='your_data.csv',  # Replace with your data file
    fromdate=datetime.datetime(2000, 1, 1),
    todate=datetime.datetime(2000, 12, 31),
    dtformat=('%Y-%m-%d'),
    openinterest=-1
)
cerebro.adddata(data)

# 5. Set the initial cash
cerebro.broker.setcash(100000.0)

# 6. Run the backtest
print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
cerebro.run()
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

import pandas as pd

# Assume 'my_dataframe' is a Pandas DataFrame with a DatetimeIndex
# and columns named 'open', 'high', 'low', 'close', 'volume'
data = bt.feeds.PandasData(dataname=my_dataframe)

def notify_order(self, order):
    if order.status in [order.Submitted, order.Accepted]:
        # Buy/Sell order submitted/accepted to/by broker - Nothing to do
        return

    # Check if an order has been completed
    if order.status in [order.Completed]:
        if order.isbuy():
            self.log(f'BUY EXECUTED, Price: {order.executed.price:.2f}, Cost: {order.executed.value:.2f}, Comm: {order.executed.comm:.2f}')
        elif order.issell():
            self.log(f'SELL EXECUTED, Price: {order.executed.price:.2f}, Cost: {order.executed.value:.2f}, Comm: {order.executed.comm:.2f}')
        self.bar_executed = len(self)
    elif order.status in [order.Canceled, order.Margin, order.Rejected]:
        self.log('Order Canceled/Margin/Rejected')

    # Write down: no pending order
    self.order = None

def notify_trade(self, trade):
    if not trade.isclosed:
        return

    self.log(f'OPERATION PROFIT, GROSS {trade.pnl:.2f}, NET {trade.pnlcomm:.2f}')

class SmaCrossStrategy(bt.Strategy):
    params = dict(pfast=10, pslow=30)

    def __init__(self):
        sma_fast = bt.indicators.SMA(period=self.p.pfast)
        sma_slow = bt.indicators.SMA(period=self.p.pslow)
        self.crossover = bt.indicators.CrossOver(sma_fast, sma_slow)

    def next(self):
        if not self.position:
            if self.crossover > 0:
                self.buy()
        elif self.crossover < 0:
            self.close()

class RsiStrategy(bt.Strategy):
    params = (("rsi_period", 14), ("rsi_overbought", 70), ("rsi_oversold", 30))

    def __init__(self):
        self.rsi = bt.indicators.RSI(self.data.close, period=self.params.rsi_period)

    def next(self):
        if not self.position and self.rsi < self.params.rsi_oversold:
            self.buy()
        elif self.position and self.rsi > self.params.rsi_overbought:
            self.sell()

import backtrader as bt

class CustomStochastic(bt.Indicator):
    lines = ('k', 'd',)  # Declare the output lines
    params = (
        ('k_period', 14),  # Lookback period for HighestHigh/LowestLow
        ('d_period', 3),   # Smoothing period for the %D line
    )

    def __init__(self):
        # Use built-in indicators for the components
        highest = bt.indicators.Highest(self.data.high, period=self.p.k_period)
        lowest = bt.indicators.Lowest(self.data.low, period=self.p.k_period)

        # Calculate and assign the %K line
        self.lines.k = 100 * (self.data.close - lowest) / (highest - lowest)

        # Calculate and assign the %D line by smoothing %K
        self.lines.d = bt.indicators.SimpleMovingAverage(self.lines.k, period=self.p.d_period)

# 1. Add analyzers to Cerebro with unique names
cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='mysharpe')
cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='mytrade')

# 2. Run the backtest
results = cerebro.run()
strategy_instance = results[0]

# 3. Retrieve and print analysis from each analyzer
sharpe_analysis = strategy_instance.analyzers.mysharpe.get_analysis()
trade_analysis = strategy_instance.analyzers.mytrade.get_analysis()

print(f"Sharpe Ratio: {sharpe_analysis['sharperatio']}")
print(f"Total Trades: {trade_analysis.total.total}")
print(f"Winning Trades: {trade_analysis.won.total}")
print(f"Losing Trades: {trade_analysis.lost.total}")

cerebro.optstrategy(
    SmaCrossStrategy,
    pfast=range(10, 21, 5),  # Test with pfast = 10, 15, 20
    pslow=range(30, 51, 10)  # Test with pslow = 30, 40, 50
)

# Run the optimization
optimized_runs = cerebro.run()

final_results_list = []
for run in optimized_runs:
    for strategy in run:
        final_results_list.append({
            'pfast': strategy.p.pfast,
            'pslow': strategy.p.pslow,
            'pnl': strategy.broker.getvalue()
        })

# Sort the results by final portfolio value
by_pnl = sorted(final_results_list, key=lambda x: x['pnl'], reverse=True)

# Print the best result
print("Best performing parameters:")
print(by_pnl[0])

# Percentage-based commission for stocks (0.1%)
cerebro.broker.setcommission(commission=0.001)

# Fixed-based commission for futures
# cerebro.broker.setcommission(commission=2.0, mult=10.0, margin=2000.0)

# Percentage-based slippage (0.1%)
cerebro.broker.set_slippage_perc(perc=0.001, slip_open=True)

# Add a sizer to Cerebro to risk 20% of cash on each trade
cerebro.addsizer(bt.sizers.PercentSizer, percents=20)

# NOTE: This is a conceptual example and requires a running IB TWS/Gateway
# and the appropriate API libraries installed.

# 1. Create an IBStore instance with connection details
ibstore = bt.stores.IBStore(host='127.0.0.1', port=7497, clientId=10)

# 2. Get a live data feed from the store
data = ibstore.getdata(dataname='EUR.USD-CASH-IDEALPRO')

# 3. Get a live broker instance from the store
broker = ibstore.getbroker()

# 4. Configure Cerebro with live components
cerebro = bt.Cerebro(runonce=False)  # Use runonce=False for live data
cerebro.adddata(data)
cerebro.setbroker(broker)

# 5. Add the SAME strategy used for backtesting
cerebro.addstrategy(MyStrategy)

# 6. Run Cerebro for live trading
cerebro.run()