# 5 Best Ways to Perform Rolling Window Size 3 Average in Python Pandas DataFrames

Rate this post

π‘ Problem Formulation: In data analysis, calculating rolling averages is a fundamental technique used for smoothing out time-series data and identifying trends over a specific period. This article solves the problem of computing a rolling window size of 3 average in a Python Pandas DataFrame. Given a DataFrame with numerical values, the goal is to produce a new column that contains the average of each window of three contiguous rows.

## Method 1: Using DataFrame.rolling().mean()

This method involves using Pandas’ built-in functions for rolling calculations. The `DataFrame.rolling(window_size).mean()` function calculates the rolling mean of the specified window size for each column in the DataFrame. It’s easy to use, efficient, and the go-to method for most rolling average calculations in Pandas.

Here’s an example:

```import pandas as pd

# Create example DataFrame
df = pd.DataFrame({'values': [1, 2, 3, 4, 5]})

# Calculate rolling average with window size 3
df['rolling_avg'] = df['values'].rolling(window=3).mean()

print(df)```

The output of the code snippet:

```   values  rolling_avg
0       1          NaN
1       2          NaN
2       3          2.0
3       4          3.0
4       5          4.0```

This code snippet creates a simple Pandas DataFrame with a column of values and then adds a new column that contains the rolling average with a window size of 3 by using the `rolling()` method followed by `mean()`. The first two rows of the result contain `NaN` because there are not enough data points to calculate an average for those positions.

## Method 2: Custom Rolling Average Function

If you need more control or want to implement a rolling average manually for learning purposes, you can define a custom function. The function should take a list of numbers and a window size and return a list of averages. Be aware that custom solutions may not perform as well as native Pandas methods.

Here’s an example:

```def rolling_average(data, window_size):
return [sum(data[i:i+window_size])/window_size for i in range(len(data)-window_size+1)]

values = [1, 2, 3, 4, 5]
average_values = rolling_average(values, 3)

print("Rolling averages:", average_values)```

The output of this code snippet:

`Rolling averages: [2.0, 3.0, 4.0]`

This code snippet defines a function `rolling_average` that takes a list of values and computes the rolling average using a simple list comprehension. This is a straightforward, albeit less efficient, method for calculating rolling averages without Pandas. This function returns a list of averages and handles the calculation manually.

## Method 3: Using DataFrame.apply() with a Lambda Function

The `DataFrame.apply()` function in Pandas can be used with a lambda function to compute custom rolling windows. This method is slightly more complex than using `rolling()` directly but can be useful if you need to apply more complex transformations during the rolling window computation.

Here’s an example:

```import pandas as pd

# Create example DataFrame
df = pd.DataFrame({'values': [1, 2, 3, 4, 5]})

# Apply a custom lambda function to calculate rolling average
df['rolling_avg'] = df['values'].rolling(window=3).apply(lambda x: x.mean(), raw=True)

print(df)```

The output of this code snippet:

```   values  rolling_avg
0       1          NaN
1       2          NaN
2       3          2.0
3       4          3.0
4       5          4.0```

Similar to Method 1, this approach utilizes the `rolling()` function but allows for a lambda function to perform the average calculation. In this case, `lambda x: x.mean()` is applied to each window. This offers more flexibility at the cost of code readability when compared to the straightforward `mean()` method.

## Method 4: Using Numpy Convolve for Rolling Averages

NumPy offers a convenient function `convolve` to perform element-wise multiplication followed by a sum. When used appropriately, convolve can calculate the rolling average without explicitly looping over each window. This method leverages NumPy’s efficiency but might be less intuitive for those unfamiliar with convolution operations.

Here’s an example:

```import pandas as pd
import numpy as np

# Create DataFrame
df = pd.DataFrame({'values': [1, 2, 3, 4, 5]})

# Using NumPy's convolve to calculate the rolling average
kernel = np.ones(3) / 3
df['rolling_avg'] = np.convolve(df['values'], kernel, 'valid')

print(df)```

The output of this code snippet:

```   values  rolling_avg
0       1          NaN
1       2          NaN
2       3          2.0
3       4          3.0
4       5          4.0```

Here, we create a NumPy array called `kernel` representing the weights for the rolling average and use `np.convolve()` with the option ‘valid’ to ensure that the result has the same length as the input array minus the window size plus one. The “kernel” is essentially a uniform weight vector for the window sizes.

## Bonus One-Liner Method 5: Using pandas.Series.expanding()

Finally, for an expanding window that takes the mean of all values from the start up to the current position (albeit not exactly a rolling average of size 3), you can use the one-liner `expanding().mean()`. This approach provides cumulative averages, which could give insights into overall trends.

Here’s an example:

```import pandas as pd

# Create example DataFrame
df = pd.DataFrame({'values': [1, 2, 3, 4, 5]})

# Calculate the expanding mean
df['expanding_avg'] = df['values'].expanding(min_periods=3).mean()

print(df)```

The output of this code snippet:

```   values  expanding_avg
0       1            NaN
1       2            NaN
2       3            2.0
3       4            2.5
4       5            3.0```

The code uses `expanding().mean()` to compute the cumulative average from the beginning of the series up to each point. It’s a different take on averages that could potentially be useful as an alternative analysis. However, it is not a rolling window of a fixed size.

## Summary/Discussion

• Method 1: DataFrame.rolling().mean(). This is the most straightforward and recommended way to calculate rolling averages in Pandas. Its main strength is its efficient internal implementation, but it lacks flexibility for more complex rolling computations.
• Method 2: Custom Rolling Average Function. Good for educational purposes and offers complete control over calculations. However, it is less efficient and more verbose than built-in methods.
• Method 3: DataFrame.apply() with a Lambda Function. This method is more flexible than Method 1 and useful for complex operations, but potentially overcomplicates simple rolling window calculations.
• Method 4: Using Numpy Convolve for Rolling Averages. It provides an efficient solution with NumPy’s optimized calculations but may be less intuitive to understand and use.
• Method 5: pandas.Series.expanding(). Although it does not provide a fixed-size window average, it is useful for understanding the cumulative trend in a dataset. It’s straightforward, but the result is different from a rolling average.