2. Mastering the Relative Strength Index (RSI) with Python

In the dynamic world of financial markets, technical indicators are indispensable tools for traders and analysts seeking to understand market sentiment and predict potential price movements. Our ongoing series exploring Python for finance now delves into another cornerstone indicator: the Relative Strength Index (RSI). This powerful momentum oscillator helps gauge the speed and persistence of price changes, identifying potentially overbought or oversold conditions in stocks, commodities, or any tradable asset.

Disclaimer: This article was drafted with the assistance of artificial intelligence and reviewed by the editor prior to publication to ensure accuracy and clarity.

What is the Relative Strength Index (RSI)?

Developed by the renowned technical analyst J. Welles Wilder Jr., the RSI is a momentum oscillator that measures the magnitude of recent price changes to evaluate overbought or oversold conditions in the price of an asset. 

It operates by comparing the average size of gains on days when the price closed up to the average size of losses on days when the price closed down over a specific period, typically 14 periods (days, hours, etc.). The result is an index that oscillates between 0 and 100.

Key Characteristics and Signals of RSI:

• Range: Fluctuates between 0 and 100.
• Overbought/Oversold Thresholds: Traditionally, an RSI reading above 70 suggests an asset might be overbought (potentially due for a price pullback), while a reading below 30 indicates it might be oversold (potentially due for a price rebound). These are guidelines, not definitive signals, and can vary based on the asset and market conditions.
• Divergence: This is often considered one of the stronger RSI signals.
  • Bullish Divergence: Occurs when the asset’s price makes a new low, but the RSI makes a higher low. This can suggest that downside momentum is weakening and a potential uptrend reversal could occur.
  • Bearish Divergence: Occurs when the asset’s price reaches a new high, but the RSI makes a lower high. This can indicate that upside momentum is fading and a potential downtrend reversal might be imminent.
• Centerline Crossover: The 50 level acts as a midpoint.
  • Crossing Above 50: Often interpreted as a sign of increasing bullish momentum (average gains are overpowering average losses).
  • Crossing Below 50: Often interpreted as a sign of increasing bearish momentum (average losses are overpowering average gains).
• Failure Swings: (Advanced) These occur when the RSI peaks above 70, pulls back, fails to exceed its previous peak on a subsequent rally, and then breaks below its recent low (Top Failure Swing – bearish). Conversely, a Bottom Failure Swing (bullish) occurs below 30.

Implementing RSI with Python: A Step-by-Step Guide

Let’s walk through how to calculate and visualize the RSI for Tesla (TSLA) stock using Python, leveraging popular libraries like yfinance, pandas, and matplotlib, using the specific code implementation you provided.

Step 1: Import Libraries and Fetch Data

First, we need to import the necessary libraries and download the historical stock price data for the specified period.

# Step 1: Import Libraries and Fetch Data
import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Define the stock and time period
ticker = 'TSLA'
start_date = '2023-01-01'
end_date = '2024-01-01'

# Download data
data = yf.download(ticker, start=start_date, end=end_date)

# Display the first few rows to verify (optional)
# print(data.head())

Explanation:

1. Import Libraries: We import yfinance (aliased as yf) for fetching data, pandas (as pd) for data structures, matplotlib.pyplot (as plt) for plotting, and numpy (as np).
2. Define Parameters: We set the ticker symbol (‘TSLA’) and the fixed start_date (‘2023-01-01’) and end_date(‘2024-01-01’).
3. Download Data: yf.download() fetches the historical stock data for Tesla within the specified dates and stores it in the data DataFrame.

Step 2: Calculate the Relative Strength Index (RSI)

Now, we define and use the function provided to calculate the RSI. Important Note: This specific implementation calculates the average gains and losses using a Simple Moving Average (SMA) via .rolling().mean(). This is a valid approach but differs from J. Welles Wilder’s original RSI calculation, which uses a specific smoothing technique (an exponential moving average). Therefore, the RSI values produced by this code might differ slightly from those calculated using the standard Wilder’s method found in many charting platforms or other libraries.

# Step 2: Calculate RSI
def calculate_rsi(prices, period=14):
    # Calculate price changes
    delta = prices.diff()

    # Separate gains and losses
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)

    # Calculate average gain and loss using SMA (Simple Moving Average)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()

    # Calculate RS (Relative Strength)
    # Note: Potential for division by zero if avg_loss is zero during the initial period.
    # Pandas handles this by yielding infinity, which results in RSI of 100.
    rs = avg_gain / avg_loss

    # Calculate RSI
    rsi = 100 - (100 / (1 + rs))

    return rsi

# Calculate 14-day RSI using the defined function
data['RSI'] = calculate_rsi(data['Close'])

# Display data with RSI (optional)
# print(data.tail())

Explanation (calculate_rsi function):

1. Calculate delta: prices.diff() calculates the difference between each day’s closing price and the previous day’s closing price. The first value will be NaN.
2. Separate gain and loss: delta.where(delta > 0, 0) keeps only positive changes (gains), setting others to 0. -delta.where(delta < 0, 0) isolates negative changes, makes them positive (losses), and sets others to 0.
3. Calculate Average Gain/Loss (SMA): gain.rolling(window=period).mean() calculates the simple moving average of gains over the specified period (default 14). The same is done for losses. Note that the first period-1values will be NaN because a full window is needed for the SMA calculation.
4. Calculate RS: The Relative Strength (RS) is calculated by dividing the avg_gain by the avg_loss.
5. Calculate RSI: The final RSI value is calculated using the formula 100 - (100 / (1 + RS)).
6. Apply to DataFrame: The calculate_rsi function is called with the ‘Close’ price Series, and the resulting RSI values are stored in a new ‘RSI’ column in the data DataFrame.

Step 3: Visualize Price and RSI

A visual representation makes interpreting RSI much easier. We’ll plot the closing price and the RSI indicator in two separate subplots using the provided plotting code.

# Step 3: Visualize RSI
# Create a figure with two subplots
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), gridspec_kw={'height_ratios': [3, 1]})

# Plot price on the first subplot
ax1.plot(data.index, data['Close'], color='blue')
ax1.set_title(f'{ticker} Price', fontsize=14)
ax1.set_ylabel('Price ($)', fontsize=12)
ax1.grid(True, alpha=0.3)

# Plot RSI on the second subplot
ax2.plot(data.index, data['RSI'], color='purple')
ax2.set_title('Relative Strength Index (RSI)', fontsize=14)
ax2.set_ylabel('RSI', fontsize=12)
ax2.set_xlabel('Date', fontsize=12)
ax2.grid(True, alpha=0.3)

# Add overbought and oversold lines
ax2.axhline(70, color='red', linestyle='--', alpha=0.5)
ax2.axhline(30, color='green', linestyle='--', alpha=0.5)
ax2.axhline(50, color='black', linestyle='-', alpha=0.2) # Centerline

# Set RSI y-axis limits
ax2.set_ylim(0, 100)

plt.tight_layout() # Adjust layout to prevent overlapping titles/labels
plt.show()

Explanation:

1. Create Subplots: plt.subplots(2, 1, ...) creates a figure and two vertically stacked axes (ax1, ax2). gridspec_kw gives the top plot (price) 3 times the height of the bottom plot (RSI).
2. Plot Price: ax1.plot() draws the closing price against the date index on the top subplot. Titles, labels, and a light grid are added.
3. Plot RSI: ax2.plot() draws the calculated RSI values on the bottom subplot.
4. Add Horizontal Lines: ax2.axhline() adds reference lines at 70 (red dashed), 30 (green dashed), and 50 (black solid, lighter).
5. Set Y-Limits: ax2.set_ylim(0, 100) fixes the RSI plot’s vertical axis range.
6. Labels and Layout: Titles and labels are added. plt.tight_layout() optimizes spacing, and plt.show()displays the chart.

Interpreting the Chart

When examining the generated chart for Tesla (TSLA) between January 1, 2023, and January 1, 2024, you would look for:

• RSI crossing below 30: Potential oversold condition.
• RSI crossing above 70: Potential overbought condition.
• Divergences: Instances where price and RSI move in opposite directions (e.g., higher price highs but lower RSI highs).
• Centerline Crosses: Crossings of the 50 line indicating potential shifts in momentum dominance (gains vs. losses).

Below is the output of the code:

The chart shows a volatile period (normal for Tesla) for the underlying asset between March 2023 and January 2024, characterized by strong rallies pushing the RSI into overbought territory (especially mid-year) followed by sharp sell-offs driving it into oversold territory. These oscillations suggest potential turning points in price when the RSI reached extreme levels (above 70 or below 30).

Limitations and Considerations

While RSI is a valuable tool, remember:

• Lagging Indicator: RSI is based on past price data.
• Subjective Thresholds: 70/30 levels are traditional; they might need adjustment based on market context. Assets can stay overbought/oversold in strong trends.
• Calculation Method: As noted, the provided code uses an SMA-based RSI, which may differ from the standard Wilder’s smoothed RSI. Be aware of this difference when comparing to other sources.
• Whipsaws: Sideways markets can cause frequent, potentially misleading, signal line crosses.
• Confirmation Needed: Use RSI in conjunction with other analysis methods (price action, volume, other indicators) for more robust signals.

Conclusion

The Relative Strength Index (RSI) is a versatile and widely used momentum indicator. Python, with libraries like yfinance, pandas, and matplotlib, provides a straightforward way to calculate and visualize it, as demonstrated by the provided code. Understanding how this specific implementation works (using SMA for averages), interpreting its signals, and acknowledging its limitations allows for more informed analysis within the context of a broader trading strategy.

Disclaimer: This analysis is for educational purposes only and not financial advice. Technical indicators are based on historical data and do not guarantee future results. Investing involves risks, including the potential loss of principal. Consult a qualified financial advisor before making investment decisions.