Rolling Sum in Python

The rolling sum (also known as a moving average) is a crucial concept in data analysis and time series manipulation. It involves calculating the sum of a fixed-size sliding window across a sequence of numbers.

This article explores different methods to implement the rolling sum in Python, including using NumPy and Pandas, ensuring you have a robust understanding with clear examples and code outputs. Whether you’re working with financial data, sensor readings, or any sequential dataset, mastering the rolling sum with Python, NumPy, and Pandas is essential. We will show you how to calculate rolling sum on a list using different methods.

Example Input:

 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 window_size = 3
 

Expected Output:

 Rolling Sum (Method 1): [6, 9, 12, 15, 18, 21, 24, 27]
 Rolling Sum (Method 2): [6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0]
 Rolling Sum (Method 3): [6, 9, 12, 15, 18, 21, 24, 27]
 

Method 1: Implementing Rolling Sum with a Loop

This method utilizes a simple loop to iterate through the list and calculate the rolling sum. It’s straightforward and easy to understand, making it a good starting point for beginners.

 def rolling_sum_loop(numbers, window_size):
     if len(numbers) < window_size:
         return []
     
     rolling_sums = []
     for i in range(len(numbers) - window_size + 1):
         window = numbers[i:i+window_size]
         rolling_sums.append(sum(window))
     return rolling_sums
 

 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 window_size = 3
 result = rolling_sum_loop(numbers, window_size)
 print(f"Rolling Sum (Method 1): {result}")
 

 Rolling Sum (Method 1): [6, 9, 12, 15, 18, 21, 24, 27]
 

Explanation: The function rolling_sum_loop takes a list of numbers and a window size as input. It iterates through the list, creating a “window” of the specified size at each step. The sum of the numbers within the window is calculated and appended to the rolling_sums list, which is returned as the result.

Method 2: Using NumPy’s convolve Function

NumPy’s convolve function provides an efficient way to compute the rolling sum. This method leverages optimized array operations for faster computation, especially beneficial for large datasets.

 import numpy as np
 

 def rolling_sum_numpy_convolve(numbers, window_size):
     if len(numbers) < window_size:
         return []
     
     window = np.ones(window_size)
     numbers_np = np.array(numbers)
     rolling_sums = np.convolve(numbers_np, window, mode='valid')
     return rolling_sums.tolist()
 

 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 window_size = 3
 result = rolling_sum_numpy_convolve(numbers, window_size)
 print(f"Rolling Sum (Method 2): {result}")
 

 Rolling Sum (Method 2): [6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0]
 

Explanation: This method first converts the input list to a NumPy array. It creates a window of ones using np.ones() and then uses np.convolve to perform the convolution. The mode='valid' argument ensures that only the parts of the convolution where the window fully overlaps with the input array are returned. The result is converted back to a list for consistency.

Method 3: Using List Comprehension and sum()

This method provides a concise and readable way to compute the rolling sum using list comprehension. It’s more Pythonic and can be faster than a traditional loop for smaller datasets.

 def rolling_sum_list_comprehension(numbers, window_size):
     if len(numbers) < window_size:
         return []
     
     rolling_sums = [sum(numbers[i:i+window_size]) for i in range(len(numbers) - window_size + 1)]
     return rolling_sums
 

 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 window_size = 3
 result = rolling_sum_list_comprehension(numbers, window_size)
 print(f"Rolling Sum (Method 3): {result}")
 

 Rolling Sum (Method 3): [6, 9, 12, 15, 18, 21, 24, 27]
 

Explanation: This method uses list comprehension to create a new list of rolling sums. For each index i, it calculates the sum of the sublist numbers[i:i+window_size], effectively creating the rolling sum in a single line of code. This approach is often more readable and concise than using a traditional for loop.