By the end of this tutorial, a professional will be equipped to:

You will gain the most from this tutorial if you have a basic understanding of financial instruments. Additionally, basic skill in the Python programming language is necessary to follow the practical examples.

These libraries can be installed using Python’s package installer, pip. It is best practice to manage these dependencies within a dedicated virtual environment.

pip install pandas numpy yfinance matplotlib seaborn scikit-learn

import pandas as pd
import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import PowerTransformer
import scipy.stats as stats

# Define the ticker symbol and the date range
ticker = 'SPY'
start_date = '2020-01-01'
end_date = pd.to_datetime('today')

# Fetch the historical data
spy_data = yf.download(ticker, start=start_date, end=end_date)

# Display the first few rows of the DataFrame
print(spy_data.head())

Executing this code will produce a table that serves as the raw material for the entire tutorial. It allows for a visual confirmation that the data has been loaded correctly.

Table 1: Sample of Downloaded Historical Data for SPY

Crucial Insight: Why Quants Prefer Log Returns

With the data acquired, the next task is to calculate returns. A simple percentage change, or simple return, is defined as R_s​=(P_t​−P_t−1​)/P_t−1​. It is intuitive. Though, it possesses mathematical properties that make it problematic for rigorous financial modeling.

The professional standard in quantitative finance is the logarithmic return (or continuously compounded return), defined as R_l​=ln(P_t​/P_t−1​). The preference for log returns is not arbitrary; it is rooted in several powerful mathematical advantages:

1. Time-Additivity: The cumulative log return over multiple periods is simply the sum of the log returns for each individual period. For instance, the log return over two days is
   R_l,t₀​→t₂​​=ln(P₂​/P_0​)=ln(P_2​/P₁​)+ln(P₁​/P₀​)=R_l,2​+R_l,1​.
   This property, which does not hold for simple returns, is mathematically elegant and incredibly useful for modeling and aggregating performance over time.
2. Symmetry and Bounding: Simple returns are asymmetric. A 50% loss (e.g., $100 to $50) requires a 100% gain (e.g., $50 to $100) to return to the initial value. Log returns are symmetric: ln(50/100)≈−0.693 and ln(100/50)≈+0.693. This symmetry simplifies modeling. Furthermore, financial models based on log returns ensure that asset prices do not become negative. Asset prices are derived by exponentiating the log returns.
3. Statistical Distribution: As will be explored in detail, daily log returns tend to be more closely approximated by a normal distribution than simple returns are. Many foundational financial models and statistical tests are built upon the assumption of normality, making this a vital property for practical application.

The choice between simple and log returns is a fundamental decision. A core task in quantitative finance is modeling asset price movements, often using a framework like Geometric Brownian Motion (GBM). This model, which forms the basis of the Nobel Prize-winning Black-Scholes option pricing formula, inherently assumes that the logarithm of the asset price follows a random walk. This implies that log returns are normally distributed and independent over time. If one were to use simple returns, calculating a cumulative return would require multiplying the returns. The product of normally distributed variables is not normally distributed. However, the sum of normally distributed variables is normally distributed. Therefore, choosing log returns is the first step in aligning practical analysis with the theoretical underpinnings of modern finance.

The following code calculates both simple and log returns on the ‘Close’ price and adds them as new columns to the DataFrame.

# Calculate simple returns
spy_data['simple_return'] = spy_data['Close'].pct_change()

# Calculate log returns
spy_data['log_return'] = np.log(spy_data['Close'] / spy_data['Close'].shift(1))

# Drop the first row which will have NaN values for returns
spy_data.dropna(inplace=True)

# Display the DataFrame with the new return columns
print(spy_data[['Close', 'simple_return', 'log_return']].head())

Step 2: The First Pass – Descriptive Statistics as Risk & Return Metrics

What to Do: Calculating Core Metrics

With the log returns calculated, the next step is to generate a summary of descriptive statistics. This provides an immediate, high-level “dashboard” of the asset’s historical behavior. It is often the first analytical step a quant takes to get a feel for an asset’s characteristics. The pandas library makes this exceptionally easy with the .describe() method.

Why It’s Done: A Quant’s Dashboard

This statistical summary translates directly into the language of finance, providing initial estimates for return, risk, and the range of potential outcomes.

How to Do It: Interpreting the Numbers

Executing .describe() on the log returns column produces a table that is the quantitative heart of descriptive analysis. It is an information-dense summary that serves as the industry standard for a first-pass analysis.

# Generate descriptive statistics for log returns
return_stats = spy_data['log_return'].describe()
print(return_stats)

Table 2: Descriptive Statistics for SPY Daily Log Returns

Each of these statistical measures has a direct and important financial interpretation:

• Mean: This is the first estimate of the average daily expected return. However, the mean is sensitive to extreme values (outliers).
• Median (50%): This represents the “typical” daily return, as it is the middle value in the sorted dataset. Comparing the mean and median provides a preliminary hint about the symmetry of the return distribution. If the mean is significantly different from the median, it suggests the distribution is skewed.
• Standard Deviation (std): This is arguably the most important number on this dashboard for a quant. It is the primary statistical measure of dispersion, which in finance is known as historical volatility. Volatility is the most common proxy for risk.
• Min/Max: These values show the single best and worst trading days in the dataset, highlighting the historical extremes of performance.
• Quartiles (25%, 75%): These define the Interquartile Range (IQR). The IQR gives a sense of the typical range of daily returns and is more robust to the influence of outliers than the simple range (max – min).