Learn Python tools (pandas, backtrader, zipline)

6.2.8 · Stock-Market › Backtesting Frameworks

The Foundation: pandas for Market Data

pandas pehle kyun? Kyunki saari strategies sirf OHLCV data ke transformations hain. Aapko karna hoga:

CSVs/databases ko memory mein load karna
Indicators calculate karna (SMA = Close ka rolling mean)
Signals generate karna (buy karo jab price > SMA ho)
Multiple stocks ko ek hi timeline par align karna

Core pandas Operations for Trading

Operation 1: Loading and Indexing

import pandas as pd
 
# Load stock data
df = pd.read_csv('AAPL.csv', parse_dates=['Date'], index_col='Date')
# Why parse_dates? Makes 'Date' a datetime object, unlocking time operations
# Why index_col? Puts Date as the row index, so df.loc['2024-01-15'] works
 
print(df.head())
#              Open   High    Low  Close    Volume
# Date                                            
# 2024-01-02  185.0  186.5  184.0  185.5  5000000

Yeh kyun matter karta hai: DatetimeIndex se aap date ranges ke basis par slice kar sakte ho (df['2024-01':'2024-03']), alag frequencies mein resample kar sakte ho, aur time-based joins kar sakte ho.

Operation 2: Indicators Calculate Karna

# Simple Moving Average (20-day)
df['SMA_20'] = df['Close'].rolling(window=20).mean()
 
# Why rolling()? It creates a moving window that slides over your data.
# .mean() calculates the average of those20 values at each step.
 
# Exponential Moving Average (gives more weight to recent prices)
df['EMA_12'] = df['Close'].ewm(span=12, adjust=False).mean()
 
# Why adjust=False? Matches industry-standard EMA calculation.

Rolling Mean ka Derivation: $SMA_{t} = \frac{1}{n} \sum_{i = 0}^{n - 1} P_{t - i}$ jahan $P_{t}$ = time $t$ par price, $n$ = window size.

Day 100 par 20-day SMA ke liye: $\frac{P _{100} + P _{99} + \dots + P _{81}}{20}$

Worked example Buy Signal Generate Karna

Task: Buy karo jab price 50-day SMA ke upar cross kare.

df['SMA_50'] = df['Close'].rolling(50).mean()
# Detect crossover: Close today > SMA, Close yesterday <= SMA
df['Signal'] = 0  # Default: no position
df.loc[df['Close'] > df['SMA_50'], 'Signal'] = 1  # Long position
# Actual trades happen when Signal changes
df['Position_Change'] = df['Signal'].diff()
# Position_Change == 1: BUY, -1: SELL, 0: hold
buys = df[df['Position_Change'] == 1]
print(f"Buy signals: {len(buys)}")

.diff() kyun? Yeh $Signal_{t} - Signal_{t - 1}$ compute karta hai. 0→1 ka change matlab "trade enter karo", 1→0 matlab "trade exit karo".

Common mistake Lookahead Bias ka Trap

Galat Code:

df['SMA'] = df['Close'].rolling(20).mean()
df['Signal'] = (df['Close'] > df['SMA']).astype(int)

Yeh sahi kyun lagta hai: "Bas price ko SMA se compare karo, simple!"

Problem: Yeh actually sahi hai! Lekin beginners aksar karte hain:

df['Future_Return'] = df['Close'].shift(-1) / df['Close'] - 1
df['Signal'] = (df['Future_Return'] > 0.02).astype(int)  # WRONG!

Yeh log aaj ki trade decide karne ke liye kal ka return (shift by -1) use kar rahe hain. Yeh lookahead bias hai—aap future mein jhank rahe ho.

Steel-man: "Lekin maine shift kiya hai, toh aligned hai!" Confusion yeh hai: .shift(-1) data ko UPAR move karta hai (earlier rows mein), toh df.loc['2024-01-15', 'Future_Return'] mein Jan 16 ka data hoga. Agar aap Jan 15 ko trade place karo, toh Jan 16 ka close pata nahi ho sakta.

Fix: Sirf .shift(1) ya positive shifts use karo (peeche dekhna). Signals ke liye, sirf current/past data use karo.

The Framework: backtrader for Strategy Logic

Sirf pandas kyun nahi? Aap pandas mein returns compute kar sakte ho, lekin manually karna padega:

Time ke saath cash aur positions track karna
Partial fills, slippage, commissions handle karna
Careful indexing se lookahead avoid karna
Portfolio metrics compute karna

backtrader yeh sab karta hai, taaki aap strategy logic par focus kar sako.

Anatomy of a backtrader Strategy

import backtrader as bt
 
class SmaCrossover(bt.Strategy):
    params = (('sma_short', 20), ('sma_long', 50))  # Configurable parameters
    
    def __init__(self):
        # Indicators are calculated ONCE on all data, but accessed bar-by-bar
        self.sma_short = bt.indicators.SMA(self.data.close, period=self.params.sma_short)
        self.sma_long = bt.indicators.SMA(self.data.close, period=self.params.sma_long)
        self.crossover = bt.indicators.CrossOver(self.sma_short, self.sma_long)
        
    def next(self):
        # Called for each bar (after SMA warmup period)
        if not self.position:  # No position: look for entry
            if self.crossover > 0:  # Short MA crossed above Long MA
                self.buy(size=100)  # Buy 100 shares
        else:  # Have position: look for exit
            if self.crossover < 0:  # Short MA crossed below Long MA
                self.close()  # Close position

__init__ aur next alag kyun?

__init__: Indicators define karo. backtrader inhe SAARE data par pehle se compute kar leta hai (efficient).
next: Trading logic. Sequentially call hota hai, sirf current + past bars dekh sakta hai (lookahead prevent karta hai).

CrossOver Kaise Kaam Karta Hai: