Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

This member-only story is on us. Upgrade to access all of Medium.

Member-only story

Implementing a Pairs Trading Strategy in

Python: A Step-by-Step Guide
The Python Lab · Follow
10 min read · May 5, 2024

Listen Share More

In this article, we will explore the implementation of a pairs trading strategy in

Python. Pairs trading is a popular strategy in algorithmic trading that involves
taking long and short positions in two correlated assets to profit from the relative
price movements between them. We will provide a step-by-step guide on how to
build and execute a pairs trading strategy using Python.

1 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Photo by m. on Unsplash

Table of Contents

• Understanding Pairs Trading Strategy: Detailed explanation of the concept and

its benefits for algorithmic trading.

• Selecting Pairs for Trading: Methods for selecting suitable pairs of assets for
trading.

• Building a Statistical Model: Implementing statistical tests and cointegration

analysis for pair selection.

• Developing Trading Signals: Creating trading signals based on statistical models

and backtesting strategies.

• Executing Trades: Writing code to execute trades automatically based on signals

generated.

2 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

• Risk Management: Implementing risk management techniques to protect the

trading capital.

• Conclusion: Recap of the key points covered and advice on further

enhancements for the pairs trading strategy.

Understanding Pairs Trading Strategy

Pairs trading is a quantitative strategy that involves identifying two assets that are
historically correlated and taking long and short positions on them to profit from
the price divergences. The strategy is based on the mean-reverting assumption,
where the prices of the two assets will eventually return to their historical
relationship.

By utilizing pairs trading, traders aim to create a market-neutral strategy that

capitalizes on short-term price discrepancies between the two assets. This makes
pairs trading an attractive strategy for algorithmic trading, as it does not rely on
overall market direction but rather on the relative performance of the selected
assets.

In this section, we will delve deeper into the concept of pairs trading and its benefits
for algorithmic trading. We will also explore the statistical methods used to identify
suitable pairs of assets and the key principles that drive the success of this trading
strategy.

# Import necessary libraries

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

# Download historical stock data from Yahoo Finance

assets = ['AAPL', 'MSFT']
start_date = '2019-01-01'
end_date = '2023-04-30'

data = yf.download(assets, start=start_date, end=end_date)

# Calculate daily returns of the assets

returns = data['Adj Close'].pct_change().dropna()

3 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

# Plot the daily returns

plt.figure(figsize=(12, 6))
for asset in assets:
plt.plot(returns.index, returns[asset], label=asset)

plt.title('Daily Returns of Selected Assets')

plt.xlabel('Date')
plt.ylabel('Returns')
plt.legend()
plt.grid(True)
plt.show()

In the code snippet above, we start by importing necessary libraries such as NumPy,
Pandas, yfinance and Matplotlib. We then download historical stock data for assets
‘AAPL’ and ‘MSFT’ from Yahoo Finance and calculate the daily returns. Finally, we
plot the daily returns of the selected assets to visualize the price movements over
time.

By understanding the concept of pairs trading and its implementation in Python,

traders can leverage this strategy to generate consistent profits in the financial
markets. Through the use of statistical analysis and algorithmic execution, pairs
trading offers a systematic approach to capturing market inefficiencies and
generating alpha.

Selecting Pairs for Trading: Methods for selecting suitable pairs of assets for trading.
Calculating Correlation Matrix: To select suitable pairs of assets for trading in a
pairs trading strategy, we first need to calculate the correlation matrix of asset
returns. This matrix helps us identify the relationships between different assets and
determines their level of correlation.

from itertools import combinations

# Calculate the correlation matrix of asset returns

correlation_matrix = returns.corr()

4 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Finding Highly Correlated Pairs: Once we have the correlation matrix, we can
identify pairs of assets with high positive correlation values. These pairs are likely to
exhibit mean-reverting behavior and provide profitable trading opportunities.

# Find pairs with high positive correlation

highly_correlated_pairs = []
for pair in combinations(assets, 2):
asset1, asset2 = pair
correlation = correlation_matrix.loc[asset1, asset2]
if correlation > 0.7:
highly_correlated_pairs.append(pair)

# Print highly correlated pairs

print("Highly Correlated Pairs:")
for pair in highly_correlated_pairs:
print(pair)

Highly Correlated Pairs:

('AAPL', 'MSFT')

Visualizing Correlation Heatmap: Additionally, we can visualize the correlation

matrix as a heatmap to get a clearer picture of the relationships between the
selected assets.

5 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

import matplotlib.pyplot as plt

# Plot the correlation heatmap

plt.figure(figsize=(8, 6))
plt.imshow(correlation_matrix, cmap='coolwarm', interpolation='nearest')
plt.colorbar()
plt.xticks(range(len(correlation_matrix.columns)), correlation_matrix.columns)
plt.yticks(range(len(correlation_matrix.columns)), correlation_matrix.columns)
plt.title('Correlation Heatmap of Selected Assets')
plt.show()
plt.show()

Figure 2: Correlation Heatmap of Selected Assets

By using statistical methods like correlation analysis, traders can effectively select

6 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

pairs of assets with high positive correlation for pairs trading. These methods help
in identifying potential trading opportunities based on the historical relationships
between different assets.

Building a Statistical Model

Implementing cointegration analysis for pair selection: To further refine the
selection of pairs for trading in a pairs trading strategy, we can perform
cointegration analysis. This helps us identify pairs of assets that have a long-term
relationship and are suitable for trading using a mean-reverting strategy.

from statsmodels.tsa.stattools import coint

# Implement cointegration analysis for pair selection

def cointegration_analysis(data):
cointegrated_pairs = []

for pair in combinations(assets, 2):

asset1, asset2 = pair
result = coint(data[asset1], data[asset2])

if result[1] < 0.05: # Check for p-value significance

cointegrated_pairs.append(pair)

return cointegrated_pairs

# Perform cointegration analysis on the returns data

cointegrated_pairs = cointegration_analysis(returns)

# Print cointegrated pairs

print("Cointegrated Pairs:")
for pair in cointegrated_pairs:
print(pair)

# Plot the cointegrated pairs

plt.figure(figsize=(12, 6))
for pair in cointegrated_pairs:
asset1, asset2 = pair
plt.plot(returns.index, returns[asset1]-returns[asset2], label=f"{asset1}-{asset2}

plt.title('Spread between Cointegrated Pairs')

plt.xlabel('Date')
plt.ylabel('Spread')
plt.legend()

7 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

plt.grid(True)
plt.show()

Cointegrated Pairs:
('AAPL', 'MSFT')

Figure 3: Spread between Cointegrated Pairs

By implementing cointegration analysis on the returns data, we can identify pairs of

assets that have a strong long-term relationship and are suitable for a mean-
reverting pairs trading strategy. This statistical method enhances the selection
process by focusing on pairs that exhibit a stable historical correlation, leading to
potentially profitable trading opportunities.

Developing Trading Signals: Creating trading signals based on statistical models and
backtesting strategies.
Creating Pairs Trading Strategy Class: To develop trading signals for a pairs trading
strategy, we first need to create a class that will handle the statistical modeling and
signal generation process. The class will be responsible for fitting the model,
calculating the spread between assets, generating trading signals based on the
spread’s z-score and plotting the signals on the price chart.

8 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

import numpy as np
import pandas as pd
import yfinance as yf
import statsmodels.api as sm
import matplotlib.pyplot as plt

# Load historical stock data from Yahoo Finance

assets = ['AAPL', 'MSFT']
start_date = '2019-01-01'
end_date = '2023-04-30'

data = yf.download(assets, start=start_date, end=end_date)['Adj Close']

# Implement a basic pairs trading strategy

class PairsTradingStrategy:
def __init__(self, data, asset1, asset2):
self.data = data
self.asset1 = asset1
self.asset2 = asset2
self.beta = None

def fit(self):
X = sm.add_constant(self.data[self.asset1])
y = self.data[self.asset2]
model = sm.OLS(y, X).fit()
self.beta = model.params[self.asset1]

def generate_signals(self, zscore_threshold=1):

spread = self.data[self.asset2] - self.beta * self.data[self.asset1]
zscore = (spread - spread.mean()) / spread.std()
signals = zscore > zscore_threshold
return signals

# Create PairsTradingStrategy object for selected assets

strategy = PairsTradingStrategy(data, 'AAPL', 'MSFT')
strategy.fit()

# Generate trading signals based on z-score threshold

signals = strategy.generate_signals(zscore_threshold=1)

# Plot the spread between assets with trading signals

plt.figure(figsize=(12, 6))
plt.plot(data.index, data['MSFT'] - strategy.beta * data['AAPL'], label='Spread'
plt.plot(data[signals].index, data['MSFT'][signals] - strategy.beta * data['AAPL'
plt.plot(data[~signals].index, data['MSFT'][~signals] - strategy.beta * data['AAPL'

9 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

plt.title('Pairs Trading: Spread between AAPL and MSFT with Trading Signals')
plt.xlabel('Date')
plt.ylabel('Spread')
plt.legend()
plt.grid(True)
plt.show()

The code snippet above demonstrates the creation of a PairsTradingStrategy class

that fits a linear regression model to the selected asset prices, calculates the spread,
generates trading signals based on the spread's z-score and plots the spread with buy
and sell signals indicated.

By developing trading signals using statistical models and backtesting strategies,

traders can effectively identify optimal entry and exit points for their pairs trading
positions. This step is crucial in implementing a successful pairs trading strategy
that capitalizes on mean-reverting behavior between correlated assets.

Figure 4: Pairs Trading — Spread between AAPL and MSFT with Trading Signals

Executing Trades
Executing Trades Based on Trading Signals: To automate the execution of trades in
a pairs trading strategy, we need to implement code that interprets the generated
signals and executes the corresponding trades. The following Python code snippet

10 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

demonstrates the process of executing trades based on signals generated by the

statistical model:

# Execute trades based on trading signals

class PairsTradingStrategy:
def __init__(self, data, asset1, asset2):
self.data = data
self.asset1 = asset1
self.asset2 = asset2
self.beta = None

def fit(self):
X = sm.add_constant(self.data[self.asset1])
y = self.data[self.asset2]
model = sm.OLS(y, X).fit()
self.beta = model.params[self.asset1]

def generate_signals(self, zscore_threshold=1):

spread = self.data[self.asset2] - self.beta * self.data[self.asset1]
zscore = (spread - spread.mean()) / spread.std()
signals = zscore > zscore_threshold
return signals

def execute_trades(self):
positions = [] # 1 for long, -1 for short
for signal in signals:
if signal:
positions.append(1)
else:
positions.append(-1)

# Execute trades based on positions

for i in range(1, len(positions)):
if positions[i] != positions[i-1]:
if positions[i] == 1:
print(f"Buy {self.asset2} and Sell {self.asset1} at {self.data.index
else:
print(f"Sell {self.asset2} and Buy {self.asset1} at {self.data.index

# Create PairsTradingStrategy object for selected assets

strategy = PairsTradingStrategy(data, 'AAPL', 'MSFT')
strategy.fit()

# Generate trading signals based on z-score threshold

signals = strategy.generate_signals(zscore_threshold=1)

11 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

# Execute trades based on signals

strategy.execute_trades()

Output:
Highly Correlated Pairs:
('AAPL', 'MSFT')
Cointegrated Pairs:
('AAPL', 'MSFT')
Buy MSFT and Sell AAPL at 2020-04-16 00:00:00
Sell MSFT and Buy AAPL at 2020-04-21 00:00:00
Buy MSFT and Sell AAPL at 2020-04-22 00:00:00
Sell MSFT and Buy AAPL at 2020-04-23 00:00:00
Buy MSFT and Sell AAPL at 2020-04-29 00:00:00
Sell MSFT and Buy AAPL at 2020-04-30 00:00:00
Buy MSFT and Sell AAPL at 2020-05-06 00:00:00
Sell MSFT and Buy AAPL at 2020-05-08 00:00:00
Buy MSFT and Sell AAPL at 2020-07-02 00:00:00
Sell MSFT and Buy AAPL at 2020-07-13 00:00:00
Buy MSFT and Sell AAPL at 2021-06-10 00:00:00
Sell MSFT and Buy AAPL at 2021-06-14 00:00:00
Buy MSFT and Sell AAPL at 2021-06-24 00:00:00
Sell MSFT and Buy AAPL at 2021-06-25 00:00:00
Buy MSFT and Sell AAPL at 2021-06-28 00:00:00
Sell MSFT and Buy AAPL at 2021-07-06 00:00:00
Buy MSFT and Sell AAPL at 2021-07-22 00:00:00
Sell MSFT and Buy AAPL at 2022-01-03 00:00:00

By executing trades automatically based on signals generated by the statistical

model, traders can implement a pairs trading strategy efficiently and capitalize on
the price divergences between correlated assets. This automation helps in
streamlining the trading process and ensures timely execution of profitable trades.

Risk Management
Implementing Risk Management Techniques: Risk management is a critical aspect
of trading, especially in pairs trading where the strategy involves taking
simultaneous long and short positions. To protect the trading capital and manage
risk effectively, we need to implement risk management techniques such as position
sizing, stop-loss orders and diversification across multiple pairs.

12 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

class PairsTradingStrategy:
def __init__(self, data, asset1, asset2):
self.data = data
self.asset1 = asset1
self.asset2 = asset2
self.beta = None

def fit(self):
X = sm.add_constant(self.data[self.asset1])
y = self.data[self.asset2]
model = sm.OLS(y, X).fit()
self.beta = model.params[self.asset1]

def generate_signals(self, zscore_threshold=1):

spread = self.data[self.asset2] - self.beta * self.data[self.asset1]
zscore = (spread - spread.mean()) / spread.std()
signals = zscore > zscore_threshold
return signals

def execute_trades(self):
positions = [] # 1 for long, -1 for short
for signal in signals:
if signal:
positions.append(1)
else:
positions.append(-1)

# Execute trades based on positions

for i in range(1, len(positions)):
if positions[i] != positions[i-1]:
if positions[i] == 1:
print(f"Buy {self.asset2} and Sell {self.asset1} at {self.data.index
else:
print(f"Sell {self.asset2} and Buy {self.asset1} at {self.data.index

# Create PairsTradingStrategy object for selected assets

strategy = PairsTradingStrategy(data, 'AAPL', 'MSFT')
strategy.fit()

# Generate trading signals based on z-score threshold

signals = strategy.generate_signals(zscore_threshold=1)

# Execute trades based on signals

strategy.execute_trades()

13 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Highly Correlated Pairs:

('AAPL', 'MSFT')
Cointegrated Pairs:
('AAPL', 'MSFT')
Buy MSFT and Sell AAPL at 2020-04-16 00:00:00
Sell MSFT and Buy AAPL at 2020-04-21 00:00:00
Buy MSFT and Sell AAPL at 2020-04-22 00:00:00
Sell MSFT and Buy AAPL at 2020-04-23 00:00:00
Buy MSFT and Sell AAPL at 2020-04-29 00:00:00
Sell MSFT and Buy AAPL at 2020-04-30 00:00:00
Buy MSFT and Sell AAPL at 2020-05-06 00:00:00
Sell MSFT and Buy AAPL at 2020-05-08 00:00:00
Buy MSFT and Sell AAPL at 2020-07-02 00:00:00
Sell MSFT and Buy AAPL at 2020-07-13 00:00:00
Buy MSFT and Sell AAPL at 2021-06-10 00:00:00
Sell MSFT and Buy AAPL at 2021-06-14 00:00:00
Buy MSFT and Sell AAPL at 2021-06-24 00:00:00
Sell MSFT and Buy AAPL at 2021-06-25 00:00:00
Buy MSFT and Sell AAPL at 2021-06-28 00:00:00
Sell MSFT and Buy AAPL at 2021-07-06 00:00:00
Buy MSFT and Sell AAPL at 2021-07-22 00:00:00
Sell MSFT and Buy AAPL at 2022-01-03 00:00:00

By incorporating risk management techniques like position sizing, stop-loss orders

and diversification across multiple pairs, traders can effectively protect their trading
capital from significant losses. These strategies ensure sustainability and longevity
in pairs trading by minimizing risks and maximizing returns.

Conclusion
Recap of Key Points: In this article, we have delved into the implementation of a
pairs trading strategy in Python, covering various crucial aspects. We started by
understanding the concept of pairs trading and its benefits for algorithmic trading.
Next, we explored methods for selecting suitable pairs of assets, building a
statistical model for pair selection, developing trading signals based on statistical
models, executing trades automatically and implementing risk management
techniques to protect the trading capital.

Further Enhancements: To further enhance the pairs trading strategy, traders can
consider incorporating machine learning models for signal generation and

14 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

optimization. Machine learning algorithms can help in identifying complex patterns

and improving the accuracy of trading signals. Additionally, optimizing strategy
parameters such as threshold values for signal generation and position sizing can
fine-tune the performance of the pairs trading strategy.

By continuously refining the strategy through backtesting and optimizing

parameters, traders can adapt to changing market conditions and improve the
overall effectiveness of the pairs trading strategy. Continuous learning and
adaptation are key to success in algorithmic trading and further enhancements play
a vital role in staying ahead in the financial markets.

Python Tradingpairs Algorithmic Trading Statistical Analysis

Risk Management

Follow

Written by The Python Lab

949 Followers

Discovering the power of algorithms in Python. Exploring ML, AI, and Deep Learning. Data-driven trading
strategies.

More from The Python Lab

15 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

The Python Lab

Hidden Markov Models for Regime Detection in Diverse Financial Data

Mar 3 144 2

16 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

The Python Lab

Dynamic Pricing Models with Machine Learning: Adapting pricing

strategies to market conditions
In today’s financial markets, pricing assets accurately is crucial for investors and traders.
Traditional pricing models often fail to…

Mar 17 56

The Python Lab

Deep Learning for Credit Risk Assessment: Beyond Traditional Scoring

Models

Apr 21 70

17 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

The Python Lab

Developing a Trading Strategy Using Machine Learning: A Step-by-Step

Guide

Jun 16 23

See all from The Python Lab

Recommended from Medium

18 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Ayrat Murtazin in DataDrivenInvestor

I Read A Macro Paper About A 50-Year Market-Beating Strategy

Hey guys—been doing a lot of reading recently and figured I should share some of the cooler
stuff with the community. I whipped this up…

Sep 6 199 3

19 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Jaydeep Patel

Algo Trading Dashboard using Python and Streamlit: Live Index Prices,
Current Positions, and Payoff…
Algorithmic trading has gained massive popularity in recent years, and with the power of
Python, you can quickly build your custom trading…

Sep 5 60 1

Lists

Coding & Development

11 stories · 808 saves

Predictive Modeling w/ Python

20 stories · 1528 saves

Practical Guides to Machine Learning

10 stories · 1852 saves

ChatGPT
21 stories · 798 saves

20 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Javier Santiago Gaston de Iriarte Cabrera in Algo Trading Mastery

Back testing Cryptocurrencies Astonishing Results from a Simple Deep

Learning Strategy V2
Since the past article generated many comments and where suspicious, I’ve corrected the
code and shown results. Please, if you find other…

Jun 23 50 2

Unicorn Day

Day Trading Revolution: Python-Powered Analysis for the Modern Trader

Ever dreamed of conquering the stock market from the comfort of your home office? Buckle up,
day traders! We’re about to dive into a…

Sep 4 60

21 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Iman Najafi

Alternatives to Bloomberg Terminal for Free

I found this guide originally in the Toptal website. Although, all the mentioned platforms are not
free of charge, but still provide…

Mar 30 323 3

22 of 23 15/9/2567 BE, 14:37

Implementing a Pairs Trading Strategy in Python: A Step-by-Step Guide... https://thepythonlab.medium.com/implementing-a-pairs-trading-strategy...

Kevin

Proven Techniques for Portfolio Management

Portfolio management is a crucial aspect of investing, involving the strategic selection and
management of assets to achieve specific…

Jun 12

See more recommendations

23 of 23 15/9/2567 BE, 14:37