Back To Top

February 15, 2024

Algorithmically Identifying Stock Price Support and Resistance

7 Essential Methods to Discover Key Price Levels in Stock Prices

Support and resistance levels are foundational concepts in the world of trading, acting as critical signposts for making informed decisions. Traders use these levels to predict future breakout or breakdown scenarios.

Traders typically discern these levels through manual observation and charting, however, with modern algorithmic techniques traders can now identify these crucial levels with enhanced precision and speed. The purpose of this article is to introduce you to 7 different techniques worth knowing in Python:

  1. Rolling Midpoint Range
  2. Fibonacci Retracement
  3. Swing Highs and Lows
  4. Pivot Point Analysis
  5. K-Means Price Clustering
  6. Volume Profiler
  7. Regression Modelling

2. Basics of Support & Resistance

Support and resistance highlight the areas where a stock’s price typically halts its upward or downward trajectory. While the support level acts as a cushion, suggesting significant buying interest, the resistance level emerges as a barrier, indicative of prevailing selling sentiment.

Using an algorithmic approach to identify these levels ensures higher accuracy and dynamically responds to market shifts. This empowers traders with an enhanced, data-driven edge in their decision-making processes.

3. Python Implementation Techniques

3.1 Rolling Midpoint Range

The Rolling Midpoint Range method employs moving averages and price range evaluations over a designated interval to highlight potential support and resistance areas. This approach fundamentally revolves around the rolling window concept:

  1. Establish the Midpoint: This midpoint is calculated by taking the average of the identified high and low values.
  2. Set Support and Resistance Levels: The method deduces support from the midpoint by subtracting half of the price range (difference between the determined high and low). Conversely, the method infers resistance by adding half of this range to the midpoint.
				
					import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

def find_levels(data, window):
    high = data['High'].rolling(window=window).max()
    low = data['Low'].rolling(window=window).min()
    midpoint = (high + low) / 2
    diff = high - low
    resistance = midpoint + (diff / 2)
    support = midpoint - (diff / 2)
    return support, resistance

# Download historical stock prices
symbol = "MSFT"
start_date = '2018-01-01'
end_date = '2023-12-30'
data = yf.download(symbol, start=start_date, end=end_date)

window = 30

# Calculate support and resistance levels
support, resistance = find_levels(data, window)

# Plot the stock price, support, and resistance lines
fig, ax = plt.subplots(figsize=(24, 8))
ax.plot(data.index, data['Close'], label='Stock Price')
ax.plot(data.index, support, label='Support', linestyle='--', color='green')
ax.plot(data.index, resistance, label='Resistance', linestyle='--', color='red')
ax.set_xlabel('Date')
ax.set_ylabel('Price')
ax.set_title(f'{symbol} Stock Price with Support and Resistance Levels')
ax.legend()

# Add annotations for last support and resistance levels
last_support = support.iloc[-1]
last_resistance = resistance.iloc[-1]
ax.annotate(f'Support: {last_support:.2f}', xy=(support.index[-1], last_support),
            xytext=(support.index[-1] - pd.DateOffset(days=30), last_support + 10),
            arrowprops=dict(facecolor='green', arrowstyle='->'))
ax.annotate(f'Resistance: {last_resistance:.2f}', xy=(resistance.index[-1], last_resistance),
            xytext=(resistance.index[-1] - pd.DateOffset(days=30), last_resistance - 10),
            arrowprops=dict(facecolor='red', arrowstyle='->'))

plt.show()
				
			
Rolling Midpoint Range method Entreprenerdly.com

Figure. 1: Microsoft’s stock price from 2018 to 2023, overlaid with dynamic support (green dashed line) and resistance (red dashed line) levels derived from the Rolling Midpoint Range method. The annotations indicate the most recent levels, emphasizing their relevance to current trading conditions.

3.2 Fibonacci Retracement

Fibonacci Retracement, grounded in the Fibonacci sequence established by Leonardo Fibonacci in the 13th century, is a pivotal technical analysis tool. It pinpoints potential support and resistance zones, assisting traders in identifying prospective market reversal points. Here’s a concise breakdown:

  1. Application in Trading: Traders use these percentages to create horizontal lines on price charts, marking areas where prices might pivot. Such levels, particularly the 61.8% (Golden Ratio), are rooted in the Fibonacci sequence and have shown consistent relevance in influencing stock price behavior.
				
					import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Get the stock data for ASML.AS
symbol = "GOOG"
stock_data = yf.download(symbol, start="2020-01-01", end="2023-12-17")

# Define the lookback period for calculating high and low prices
lookback_period = 15

# Calculate the high and low prices over the lookback period
high_prices = stock_data["High"].rolling(window=lookback_period).max()
low_prices = stock_data["Low"].rolling(window=lookback_period).min()

# Calculate the price difference and Fibonacci levels
price_diff = high_prices - low_prices
levels = np.array([0, 0.236, 0.382, 0.5, 0.618, 0.786, 1])
fib_levels = low_prices.values.reshape(-1, 1) + price_diff.values.reshape(-1, 1) * levels

# Get the last price for each Fibonacci level
last_prices = fib_levels[-1, :]

# Define a color palette for the Fibonacci levels
colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']

# Plot the stock price with the Fibonacci retracement levels and last prices
fig, ax = plt.subplots(figsize=(24,8))
ax.plot(stock_data.index, stock_data["Close"], label="Stock Price")

offsets = [-16, -14, -12, -10, 8, 10, 12] 

for i, level in enumerate(levels):
    if level == 0 or level == 1:
        linestyle = "--"
    else:
        linestyle = "-"
    ax.plot(stock_data.index, fib_levels[:, i], label=f"Fib {level:.3f}", linestyle=linestyle, color=colors[i])
    ax.annotate(f"{last_prices[i]:.2f}", 
                xy=(stock_data.index[-1], fib_levels[-1, i]), 
                xytext=(stock_data.index[-1] + pd.Timedelta(days=5), fib_levels[-1, i] + offsets[i]), 
                ha="left", va="center", fontsize=16, color=colors[i])

ax.set_xlabel("Date")
ax.set_ylabel("Price")
ax.set_title(f"{symbol} with Fibonacci Retracement Levels")
ax.legend(loc="lower right", fontsize=14)

plt.show()
				
			
fibonacci retracement entreprenerdly.com

Figure. 2: Google’s stock price trend from 2020 to 2023, interspersed with Fibonacci retracement levels. These lines mark potential inflection points, providing insight into areas of support or resistance based on the age-old Fibonacci sequence.

3.3 Swing Highs and Lows

Swing trading focuses on capitalizing on short-term price fluctuations by pinpointing key inflection points on a stock’s chart, known as “swing highs” and “swing lows.” These represent local maxima and minima where a stock’s price has reached a temporary peak or valley and might be poised to reverse its direction.

  1. Spotting Swing Lows: Conversely, these are points where the stock price is lower than those immediately adjacent, indicating potential support levels.

Related Article

Top 36 Moving Average Methods For Stock Prices in Python

Fundamental Techniques, Adaptive and Dynamic, Advanced Weighting and From Niche to Noteworthy
Prev Post

Modelling Extreme Stock Market Events With Copulas in Python

Next Post

Dynamic Risk Management Using Rolling Stock Price Metrics

post-bars
Mail Icon

Newsletter

Get Every Weekly Update & Insights

[mc4wp_form id=]

Leave a Comment