DEV Community: Sairaj Chowdhary

Unlocking Quantitative Analysis using Python

Sairaj Chowdhary — Sat, 02 Aug 2025 18:07:39 +0000

Unlocking Quantitative Analysis

We recognise that programming is crucial for automating calculations, managing large datasets, and developing models. Python is a great starting language due to its simplicity and powerful libraries, such as NumPy for numerical computations, Pandas for data manipulation, and Matplotlib for visualisation.
Quantitative analysis involves using mathematical and statistical methods to evaluate data, often in fields like finance, economics, or data science.
So why don’t we check out how they work together?

As a problem solver, we know a few things like Basic Statistical Analysis (like calculating Mean and Standard Deviation):

import numpy as np
returns = [0.01, -0.02, 0.03, 0.015, -0.005]

mean_return = np.mean(returns)
print(f"Mean Return: {mean_return:.4f}")
std_dev = np.std(returns)
print(f"Standard Deviation: {std_dev:.4f}")

Or maybe consider a situation like using a CSV file:

import pandas as pd

data = pd.read_csv('stock_data.csv', parse_dates=['Date'])
data.set_index('Date', inplace=True)

data['Avg'] = data['Price'].rolling(window=5).mean()
print(data.head())

import matplotlib.pyplot as plt
data['Price'].plot(label='Price')
data['Avg'].plot(label='5-Day MA')
plt.legend()
plt.show()

Or maybe something like this helps identify trends in quantitative trading strategies.

Now it’s time to know we’ll know algorithms that are super useful and every programmer should know, regardless of whether they’re part of a quant analysis.

Monte Carlo Simulation

import numpy as np
import matplotlib.pyplot as plt

initial_price = 100
days = 252  # Trading days in a year
mean_return = 0.001  # Daily return
volatility = 0.01  # Daily volatility
simulations = 1000

prices = np.zeros((days, simulations))
prices[0] = initial_price

for t in range(1, days):
    shocks = np.random.normal(mean_return, volatility, simulations)
    prices[t] = prices[t-1] * (1 + shocks)

plt.plot(prices[:, :5])
plt.title('Monte Carlo Simulation of Stock Prices')
plt.show()

# Here I am just checking using a few examples.
final_prices = prices[-1]
print(f"Mean Final Price: {np.mean(final_prices):.2f}")
print(f"Std Dev of Final Prices: {np.std(final_prices):.2f}")

You can simulate future stock prices using random walks. This model's uncertainty, common in options pricing

And recently, I was going through a coding platform. And I’ve come across this problem that is super good to solve. Check this one.

Question: You are given an array of integers representing daily stock prices. Find the maximum profit you can achieve by buying on one day and selling on a later day. If no profit is possible, return 0.

Let's just assume:
Ex-1
Input: prices = [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
Ex-2
Input: prices = [7,6,4,3,1]
Output: 0
Explanation: In this case, no transactions are done and the max profit = 0.

Let's just assume constraints:
1 <= prices.length <= 10^5
0 <= prices[i] <= 10^4

My solution

def maxProfit(self, prices: List[int]) -> int:
        min_price = math.inf
        max_profit = 0
        for price in prices:
            min_price = min(min_price, price)
            potential_profit = price - min_price
            max_profit = max(max_profit, potential_profit)
        return max_profit

here as we iterate through the prices list, min_price = min(min_price, price) keeps a running memory of the absolute lowest price encountered
And I implemented max_profit = max(max_profit, potential_profit) to check if this profit is better than any other profit we could have made on a previous day.
It's just a single-pass iteration, and it only needs to go through the list of prices once. Pretty much greedy. It has a time complexity of O(N).

How I would start Quantitative Analysis from scratch.

Sairaj Chowdhary — Wed, 16 Jul 2025 06:27:19 +0000

Beyond the Random Walk:
If you've ever tried to learn quantitative analysis, you've likely been met with a wall of Greek letters and concepts like Brownian motion, Ito's Lemma, and autoregressive models. The traditional approach is rooted in a single, core idea: financial markets are, for the most part, a "random walk." The goal, then, is to find the tiny, fleeting signals hidden within that noise.

This is a valid approach, but it's not the only one. And for a beginner, it can be mathematically daunting and intuitively unsatisfying.

What if, instead of starting with randomness, you started with information? What if, instead of looking for linear patterns, you looked for the hidden shape of the market? This article proposes a different starting point for your quant journey, one that leverages unique, powerful concepts that are more intuitive and, arguably, more fundamental.

Ditch the Brownian Motion, Embrace the Surprise: Starting with Information Theory
Traditional finance models the path. Information theory models the surprise at each step of that path. The core idea was developed by Claude Shannon, the father of the information age, and it's called Entropy.

In simple terms, Shannon Entropy is a measure of uncertainty or surprise.

A predictable event (a biased coin that always lands on heads) has zero entropy. There is no surprise.

A completely unpredictable event (a fair coin flip) has maximum entropy.

Instead of modelling price, what if we modelled the information content of market data?

A Unique Algorithm: Order Flow Entropy
Price is a lagging indicator; it's the result of thousands of buy and sell orders. The real information lies in the order flow. Imagine you could see the stream of buy and sell orders for a stock.

High Entropy State: Buyers and sellers are evenly matched. The flow is chaotic and unpredictable. The next move is uncertain.

Low Entropy State: A huge wave of buy orders suddenly floods the market. The system becomes highly predictable for a short time. The uncertainty collapses. There is less "surprise."

The Hypothesis: A sudden, sharp drop in the entropy of order flow could be a powerful signal that a large, informed entity is making a move, creating a predictable pattern just before a significant price change. You are no longer predicting price based on its past; you are predicting price based on a measurable change in the market's underlying information structure.

This concept is more direct. It's about measuring the conviction of market participants, not just the noisy outcome of their actions.

Finding the "Shape" of Market Fear: An Introduction to Topological Data Analysis (TDA)
The second unconventional tool is Topological Data Analysis (TDA). While standard statistics is great at finding lines, clusters, and correlations, it struggles with more complex structures. TDA is a field of mathematics that studies the "shape" of data, looking for things like loops, voids, and other intricate structures.

The core algorithm here is Persistent Homology.

Imagine your data is a cloud of points in space. Persistent homology works by "inflating" a ball around each data point. As the balls grow, they start to connect, forming shapes. Some of these shapes are fleeting, but others persist for a long time. TDA tracks how long these topological features—like connected components, loops, and voids—last.

A Unique Application: The Shape of Systemic Risk
How can we use this? Instead of a 2D plot of price vs. time, imagine a 3D point cloud where each point represents a single trading day, defined by:

X-axis: S&P 500 daily return

Y-axis: VIX Index level (a measure of volatility or "fear")

Z-axis: 10-Year US Treasury yield change

The Hypothesis:
In a "normal" market, the shape of this data cloud might be a dense, formless blob.
In the lead-up to a financial crisis, the data points might start to form a distinct loop or void. This shape could represent a dangerous feedback loop where high volatility (high VIX) is persistently associated with negative returns and a flight to safety (falling bond yields). The market gets "stuck" in this topological feature.
This "shape of fear" is a multi-dimensional pattern that simple correlation analysis would completely miss. Detecting the formation and persistence of such a shape could be a powerful, non-obvious indicator of systemic risk.
Your First "Unconventional" Quant Project
You don't need a PhD to start exploring these ideas. Here’s a simple roadmap:

The Mindset Shift: Your goal isn't to predict the price of Apple tomorrow. Your goal is to measure a property of the market itself. Is the market's information content changing? Is its "shape" deforming?
Gather Data: Get free daily data from Yahoo Finance for the SPY (S&P 500 ETF) and the ^VIX (Volatility Index).

Calculate "Surprise": Write a simple Python script to calculate the daily percentage change of the VIX. Then, create a histogram of these changes. Is it a perfect bell curve, or is it skewed? A skewed distribution implies that "surprise" is not symmetrical—large spikes in fear are more common than large drops. This is your first, simple information-theoretic insight.

Visualise the "Shape": Create a 2D scatter plot of (SPY daily return, VIX daily change). Now, create this plot for different years. Compare the shape of the data cloud for a calm year (like 2017) versus a volatile year (like 2008 or 2020). You will physically see the shape of the market change. This is the core intuition behind TDA.

Therefore, starting your quantitative analysis journey with these concepts has a distinct advantage. It forces you to think about the market not as a series of numbers to be fit by an equation, but as a complex system with its structure, information flow, and geometry.

It's a more challenging, but ultimately more rewarding, path. Please stop trying to predict the random walk and start trying to understand the shape of the system itself.