The Moving Averages & RSI Quest: A Gandalf's Guide

#trading #finance #crypto #stocks

The Quest Begins (The "Why")

Honestly, I stared at a candlestick chart for the third time that week and felt like I was trying to read ancient runes without a torch. My buddy kept shouting, “Buy the dip!” while I was still trying to figure out if the dip was real or just market noise. I’d read a few blog posts that threw around terms like “moving average” and “RSI” like they were magic spells, but every time I tried to code them up I ended up with a tangled mess of loops, off‑by‑one errors, and NaN values that made my script look like a drunken hobbit stumbling through the Shire.

The breaking point came when I back‑tested a strategy that looked brilliant on paper—until I realized I’d been calculating the RSI on the wrong column and using a 5‑period moving average on daily data when I actually needed a 20‑period smooth. The results were… let’s just say they resembled a goblin raid on my portfolio. I needed a clear, reliable way to compute these indicators so I could focus on the story the data was telling, not on wrestling with the code.

The Revelation (The Insight)

Here’s the thing: moving averages and the Relative Strength Index (RSI) aren’t mystical artefacts; they’re just rolling statistics that smooth out price action and measure momentum. Once you see them as simple pandas operations, the whole thing clicks like finding the right key for a locked door.

Simple Moving Average (SMA) – the average of the last n closing prices. It smooths out short‑term fluctuations and helps you spot the underlying trend.
Exponential Moving Average (EMA) – similar to SMA but gives more weight to recent prices, making it react faster to new information.
RSI – a momentum oscillator that compares the magnitude of recent gains to recent losses over a set period (usually 14). It spits out a value between 0 and 100; readings above 70 hint at overbought conditions, below 30 hint at oversold.

The real “aha!” moment was realizing that pandas already gives us rolling windows (rolling()) and exponential weighting (ewm()). No need to manually slice arrays or keep track of indices. All the heavy lifting is done in a couple of lines, and the result is a clean Series aligned with your original DataFrame.

Wielding the Power (Code & Examples)

Let’s walk through a before/after scenario. Imagine you have a CSV with columns Date and Close.

The Struggle (Before)

import pandas as pd

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

# Naive SMA implementation – O(n*m) loops, prone to bugs
def sma_manual(series, window):
    result = []
    for i in range(len(series)):
        if i < window - 1:
            result.append(None)
        else:
            window_slice = series[i - window + 1:i + 1]
            result.append(sum(window_slice) / window)
    return pd.Series(result, index=series.index)

# Naive RSI implementation – lots of manual diff handling
def rsi_manual(series, window=14):
    delta = series.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)

    avg_gain = []
    avg_loss = []
    for i in range(len(series)):
        if i < window:
            avg_gain.append(None)
            avg_loss.append(None)
        else:
            avg_gain.append(gain[i-window+1:i+1].mean())
            avg_loss.append(loss[i-window+1:i+1].mean())
    rs = [g/l if l != 0 else None for g, l in zip(avg_gain, avg_loss)]
    rsi = [100 - (100 / (1 + rs_val)) if rs_val is not None else None for rs_val in rs]
    return pd.Series(rsi, index=series.index)

df['SMA_10'] = sma_manual(df['Close'], 10)
df['RSI_14'] = rsi_manual(df['Close'], 14)

What went wrong?

The manual loops are slow on large datasets.
Handling the first window‑1 entries with None creates messy NaNs that you have to drop later.
A single typo in the slice indices (like i - window instead of i - window + 1) throws off the whole calculation—debugging that felt like fighting a cave troll blindfolded.

The Victory (After)

import pandas as pd

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

# Pandas does the heavy lifting for us
df['SMA_10'] = df['Close'].rolling(window=10).mean()
df['EMA_10'] = df['Close'].ewm(span=10, adjust=False).mean()

# RSI using built‑in rolling mean on gains/losses
delta = df['Close'].diff()
gain = delta.clip(lower=0)
loss = -delta.clip(upper=0)

avg_gain = gain.rolling(window=14).mean()
avg_loss = loss.rolling(window=14).mean()

rs = avg_gain / avg_loss
df['RSI_14'] = 100 - (100 / (1 + rs))

# Quick look at the latest signals
print(df.tail())

Why this feels like leveling up:

One line for the SMA, one line for the EMA—no loops, no index fiddling.
The RSI calculation mirrors the textbook formula but stays vectorized, so it runs on millions of rows in a blink.
Pandas automatically aligns everything; the first 9 SMA values are NaN (which you can .dropna() or fill as you see fit). No more guessing where the valid data starts.

Common Traps to Avoid

Using span incorrectly in EMA – Remember that span relates to the decay factor; a span of 10 gives roughly the same weight as a 10‑period SMA but reacts faster. If you mistakenly use com or alpha, you’ll get a completely different curve.
Dividing by zero in RSI – When avg_loss is zero (a string of pure gains), rs becomes infinite and the RSI heads toward 100. The vectorized version handles this gracefully (inf leads to 100), but if you ever roll your own loop, guard against division by zero.

Why This New Power Matters

With these reliable indicators in your toolbox, you can start building real‑world strategies:

Trend‑following: Buy when the short‑EMA crosses above the long‑EMA (the classic “golden cross”) and sell or short on the opposite cross.
Mean‑reversion: Look for RSI dipping below 30 as a potential buying opportunity, or above 70 for a possible sell signal—especially when combined with support/resistance levels.
Risk management: Use the slope of the moving average to gauge trend strength; a flat SMA often precedes choppy markets where you might want to reduce position size.

The best part? You’re no longer copying snippets from random blogs and hoping they work. You understand the math, you trust the code, and you can tweak parameters with confidence. It’s like moving from swinging a wooden sword to wielding a lightsaber—you still need skill, but the tool finally matches your ambition.

Your Turn – Embark on Your Own Quest

Here’s a challenge: take any stock or crypto dataset you like, compute the 20‑day EMA and 14‑day RSI, then plot them alongside the price. Spot at least one instance where the EMA crossover lines up with an RSI extreme (either overbought or oversold). Share what you see—did it predict a move, or was it a false signal?

Got questions, ideas, or just want to geek out over indicators? Drop a comment below. Let’s keep the adventure going! 🚀

DEV Community