Getting Started with Quantitative Trading in Python

Welcome to quantitative trading! This guide will help you set up your development environment and create your first trading algorithm.

Setting Up Your Environment

First, let's create a proper Python environment for trading development:

# Create a new conda environment
conda create -n quant-trading python=3.11
conda activate quant-trading

# Install essential packages
pip install numpy pandas matplotlib jupyter yfinance
pip install alpaca-py ta-lib

Your First Trading Algorithm

Here's a simple moving average crossover strategy:

import yfinance as yf
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

class SimpleMACrossover:
    def __init__(self, symbol: str, fast_period: int = 9, slow_period: int = 21):
        self.symbol = symbol
        self.fast_period = fast_period
        self.slow_period = slow_period

    def get_historical_data(self, days: int = 365) -> pd.DataFrame:
        """Fetch historical price data"""
        end_date = datetime.now()
        start_date = end_date - timedelta(days=days)

        ticker = yf.Ticker(self.symbol)
        df = ticker.history(start=start_date, end=end_date)

        return df[['Open', 'High', 'Low', 'Close', 'Volume']]

    def calculate_signals(self, df: pd.DataFrame) -> pd.DataFrame:
        """Calculate moving averages and trading signals"""
        # Calculate moving averages
        df['fast_ma'] = df['Close'].rolling(window=self.fast_period).mean()
        df['slow_ma'] = df['Close'].rolling(window=self.slow_period).mean()

        # Generate signals
        df['signal'] = 0
        df.loc[df['fast_ma'] > df['slow_ma'], 'signal'] = 1  # Buy signal
        df.loc[df['fast_ma'] < df['slow_ma'], 'signal'] = -1  # Sell signal

        # Calculate position changes
        df['position_change'] = df['signal'].diff()
        df['buy_signal'] = df['position_change'] == 1
        df['sell_signal'] = df['position_change'] == -1

        return df

    def backtest(self, df: pd.DataFrame) -> dict:
        """Simple backtest of the strategy"""
        capital = 10000
        position = 0
        trades = []

        for index, row in df.iterrows():
            if row['buy_signal'] and position == 0:
                # Buy
                shares = capital // row['Close']
                position = shares
                capital -= shares * row['Close']
                trades.append({
                    'type': 'BUY',
                    'price': row['Close'],
                    'shares': shares,
                    'date': index
                })

            elif row['sell_signal'] and position > 0:
                # Sell
                capital += position * row['Close']
                trades.append({
                    'type': 'SELL',
                    'price': row['Close'],
                    'shares': position,
                    'date': index
                })
                position = 0

        final_value = capital + (position * df['Close'].iloc[-1])
        return_ = (final_value - 10000) / 10000 * 100

        return {
            'initial_capital': 10000,
            'final_value': final_value,
            'total_return': return_,
            'trades': len(trades),
            'position': position
        }

# Usage example
if __name__ == "__main__":
    strategy = SimpleMACrossover("AAPL")
    data = strategy.get_historical_data(days=365)
    data_with_signals = strategy.calculate_signals(data)

    results = strategy.backtest(data_with_signals)
    print(f"Strategy Results:")
    print(f"Total Return: {results['total_return']:.2f}%")
    print(f"Final Value: ${results['final_value']:.2f}")
    print(f"Number of Trades: {results['trades']}")

Understanding the Results

This simple strategy demonstrates several key concepts:

Moving Average Crossovers

• Fast MA (9-period): Responds quickly to price changes
• Slow MA (21-period): Provides trend direction
• Crossover signals: When fast crosses above slow = buy, below = sell

Backtesting Considerations

• Transaction costs: Not included in this simple example
• Slippage: Real market execution differs from close prices
• Risk management: No stop-losses or position sizing rules

Next Steps

1. Add risk management: Implement stop-loss orders
2. Incorporate transaction costs: Account for spreads and commissions
3. Test multiple assets: Diversify across different stocks/ETFs
4. Add technical indicators: RSI, MACD, Bollinger Bands
5. Paper trading: Test with real-time data before live trading

Remember, past performance doesn't guarantee future results. Always backtest thoroughly and start with small position sizes when trading live.