Pandas pct_change Function: Calculating Percentage Changes in DataFrames (With Examples)

Introduction

Pandas is a popular Python library used for data manipulation and analysis. One of its powerful features is the ability to easily calculate percentage changes using the pct_change function. This function allows you to compute the percentage change between consecutive elements in a DataFrame or Series. In this tutorial, we’ll dive deep into the pct_change function, exploring its syntax, parameters, and real-world examples to understand how it can be effectively used for analyzing time-series data.

Table of Contents

1. Understanding Percentage Change
2. Introduction to the pct_change Function
3. Syntax of the pct_change Function
4. Parameters of the pct_change Function
5. Example 1: Analyzing Stock Price Changes
6. Example 2: Analyzing Sales Data
7. Handling Missing Data
8. Handling Non-Numeric Data
9. Conclusion

1. Understanding Percentage Change

Percentage change is a common metric used to understand how a value has changed relative to its previous value. It is calculated using the formula:

[
\text{Percentage Change} = \frac{\text{New Value} – \text{Old Value}}{\text{Old Value}} \times 100
]

Percentage change is widely used in various fields such as finance, economics, and data analysis to analyze trends and fluctuations in data.

2. Introduction to the pct_change Function

The pct_change function is a powerful tool provided by the Pandas library to easily calculate percentage changes between consecutive elements in a DataFrame or Series. It is particularly useful for analyzing time-series data, where you want to understand how values change over time.

3. Syntax of the pct_change Function

The basic syntax of the pct_change function is as follows:

DataFrame.pct_change(periods=1, fill_method='pad', limit=None, freq=None)

Here’s what each parameter means:

• periods: The number of periods to shift for computing the percentage change. The default value is 1, which means the percentage change is calculated between consecutive elements.
• fill_method: This parameter specifies how missing values should be filled. The default is ‘pad’, which fills missing values with the previous non-missing value.
• limit: It limits the number of consecutive NaN (missing) values filled when fill_method is used.
• freq: This parameter is used to specify a time frequency for time-based calculations. It’s typically used when dealing with time-series data.

4. Parameters of the pct_change Function

Let’s take a closer look at the parameters of the pct_change function:

• periods: This parameter allows you to specify the number of periods to shift for computing the percentage change. For example, if you set periods=2, the function will calculate the percentage change between the current element and the element two periods back. This can be useful for analyzing trends over longer time spans.
• fill_method: In real-world data, missing values are quite common. The fill_method parameter helps you handle missing data by specifying how missing values should be filled. The default value is ‘pad’, which fills missing values with the previous non-missing value. Other options include ‘bfill’ (backward fill) and ‘nearest’.
• limit: When using fill_method, the limit parameter limits the number of consecutive NaN values filled. This can be helpful when you only want to fill a certain number of consecutive missing values.
• freq: This parameter is used to specify a time frequency for time-based calculations. It’s particularly useful when dealing with time-series data that has irregular time intervals. By setting the freq parameter, you can ensure accurate percentage change calculations based on the time intervals.

5. Example 1: Analyzing Stock Price Changes

Let’s explore a real-world example to understand how the pct_change function can be used for analyzing stock price changes over time.

Suppose we have a DataFrame containing historical stock prices of a company:

import pandas as pd

# Sample data
data = {'Date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'],
        'Price': [100, 105, 110, 108]}

df = pd.DataFrame(data)
df['Date'] = pd.to_datetime(df['Date'])
df.set_index('Date', inplace=True)

print(df)

Output:

            Price
Date             
2023-01-01    100
2023-01-02    105
2023-01-03    110
2023-01-04    108

We want to calculate the percentage change in stock prices on a daily basis:

percentage_change = df['Price'].pct_change()
print(percentage_change)

Output:

Date
2023-01-01         NaN
2023-01-02    0.050000
2023-01-03    0.047619
2023-01-04   -0.018182
Name: Price, dtype: float64

In this example, we used the pct_change function to calculate the percentage change in stock prices. The first value is NaN because there is no previous value to calculate the percentage change from. Subsequent values represent the percentage change between consecutive days.

6. Example 2: Analyzing Sales Data

Let’s consider another example involving sales data. Suppose we have a DataFrame containing monthly sales figures for a product:

import pandas as pd

# Sample data
data = {'Month': ['2022-01', '2022-02', '2022-03', '2022-04', '2022-05'],
        'Sales': [1000, 1100, 1050, 1200, 1300]}

df = pd.DataFrame(data)
df['Month'] = pd.to_datetime(df['Month'])
df.set_index('Month', inplace=True)

print(df)

Output:

            Sales
Month            
2022-01-01   1000
2022-02-01   1100
2022-03-01   1050
2022-04-01   1200
2022-05-01   1300

We want to calculate the percentage change in sales from one month to the next:

percentage_change = df['Sales'].pct_change()
print(percentage_change)

Output:

Month
2022-01-01         NaN
2022-02-01    0.100000
2022-03-01   -0.045455
2022-04-01    0.142857
2022-05-01    0.083333
Name: Sales, dtype: float64

In this example, we used the pct_change function to calculate the percentage change in sales. The first value is NaN because there is no

previous value to calculate the percentage change from. Subsequent values represent the percentage change between consecutive months.

7. Handling Missing Data

Dealing with missing data is a common challenge when working with real-world datasets. The pct_change function provides the fill_method and limit parameters to help you handle missing data effectively.

For instance, consider the following DataFrame with missing values:

import pandas as pd
import numpy as np

# Sample data with missing values
data = {'Date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'],
        'Price': [100, np.nan, 110, 108]}

df = pd.DataFrame(data)
df['Date'] = pd.to_datetime(df['Date'])
df.set_index('Date', inplace=True)

print(df)

Output:

            Price
Date             
2023-01-01  100.0
2023-01-02    NaN
2023-01-03  110.0
2023-01-04  108.0

You can use the fill_method parameter to fill missing values with the previous non-missing value:

percentage_change = df['Price'].pct_change(fill_method='pad')
print(percentage_change)

Output:

Date
2023-01-01         NaN
2023-01-02         NaN
2023-01-03    0.100000
2023-01-04   -0.018182
Name: Price, dtype: float64

In this example, the missing value on ‘2023-01-02’ is filled with the previous non-missing value (‘2023-01-01’) before calculating the percentage change.

8. Handling Non-Numeric Data

The pct_change function is designed to work with numeric data. If you try to apply it to non-numeric data, you’ll encounter an error. Make sure to clean your data and convert non-numeric values to appropriate data types before using the function.

9. Conclusion

The pct_change function in Pandas is a valuable tool for calculating percentage changes in data, especially when working with time-series datasets. It allows you to easily analyze trends, fluctuations, and growth rates. By understanding its parameters and syntax, you can effectively use this function to gain insights from your data. In this tutorial, we explored the basics of the pct_change function, saw how to apply it with real-world examples, and learned how to handle missing data. With this knowledge, you’re now equipped to use the pct_change function in your data analysis projects.