Skip to content

Need help? Join our Discord Community!

Pandas GroupBy: A Comprehensive Guide

Mastering Pandas GroupBy: A Comprehensive Guide

When it comes to data analysis, pandas is a powerful and flexible Python library that can help you tackle various tasks. Among its many useful features, the groupby method stands out for its ability to streamline your workflow by grouping and summarizing data. In this comprehensive guide, we'll dive into the ins and outs of pandas GroupBy, with practical examples to help you master this essential tool.

Want to quickly create Data Visualizations in Python?

PyGWalker is an Open Source Python Project that can help speed up the data analysis and visualization workflow directly within a Jupyter Notebook-based environments.

PyGWalker (opens in a new tab) turns your Pandas Dataframe (or Polars Dataframe) into a visual UI where you can drag and drop variables to create graphs with ease. Simply use the following code:

pip install pygwalker
import pygwalker as pyg
gwalker = pyg.walk(df)

You can run PyGWalker right now with these online notebooks:

And, don't forget to give us a ⭐️ on GitHub!

Run PyGWalker in Kaggle Notebook (opens in a new tab)Run PyGWalker in Google Colab (opens in a new tab)Give PyGWalker a ⭐️ on GitHub (opens in a new tab)
Run PyGWalker in Kaggle Notebook (opens in a new tab)Run PyGWalker in Google Colab (opens in a new tab)Run PyGWalker in Google Colab (opens in a new tab)

What is Pandas GroupBy?

Pandas GroupBy is a versatile method that allows you to group your data based on a certain criterion, such as a column or index value. With GroupBy, you can perform a wide range of aggregation functions like sum, count, mean, and many more on each group, making it easier to analyze and understand your data.

How to Use GroupBy in Pandas

To use GroupBy in pandas, you'll first need to import the pandas library and create a DataFrame. Once you have your data loaded, you can use the groupby() function to create a DataFrameGroupBy object.

import pandas as pd
# Create a DataFrame
data = {
    "Category": ["A", "B", "A", "B", "A", "B"],
    "Values": [10, 20, 30, 40, 50, 60]
df = pd.DataFrame(data)
# Group the DataFrame by the 'Category' column
grouped = df.groupby("Category")

Basic Aggregation Functions

After creating a DataFrameGroupBy object, you can perform various aggregation functions on it. Some common functions include:

  • sum: Calculate the sum of each group
  • count: Count the number of elements in each group
  • mean: Calculate the mean (average) of each group
  • median: Calculate the median of each group
  • std: Calculate the standard deviation of each group

Here's an example of how to use these functions:

# Calculate the sum of each group
sums = grouped['Values'].sum()

Advanced Aggregation with .agg()

Pandas GroupBy also provides the .agg() method, which allows you to perform multiple aggregations at once. This method can be used to apply different functions to different columns, and even to apply multiple functions to the same column.

# Apply multiple aggregation functions
result = grouped['Values'].agg(['sum', 'mean', 'std'])

Using Custom Aggregation Functions

In addition to built-in aggregation functions, pandas GroupBy allows you to apply custom functions to your data. You can achieve this by using the .apply() or .agg() methods and passing your custom function as an argument.

# Define a custom aggregation function
def custom_agg(x):
    return x.sum() / x.count()
# Apply the custom function to each group
result = grouped['Values'].apply(custom_agg)

Alternatively, you can use the .agg() method to apply the custom function:

result = grouped['Values'].agg(custom_agg)

Grouping by Multiple Columns

You may sometimes need to group your data by more than one column. To do this, simply pass a list of column names to the groupby() function. Here's an example:

data = {
    "Category": ["A", "B", "A", "B", "A", "B"],
    "Type": ["X", "X", "Y", "Y", "X", "Y"],
    "Values": [10, 20, 30, 40, 50, 60]
df = pd.DataFrame(data)
# Group the DataFrame by the 'Category' and 'Type' columns
grouped = df.groupby(["Category", "Type"])
# Calculate the sum of each group
sums = grouped['Values'].sum()

GroupBy with Filter and Transform

In some cases, you may want to apply a filter or transformation to your data before or after grouping. Pandas GroupBy provides the filter() and transform() methods for these purposes.


The filter() method allows you to filter your data based on a condition before performing the aggregation. Here's an example:

# Define a custom filter function
def custom_filter(x):
    return x['Values'].mean() > 25
# Apply the filter function and calculate the mean of each group
result = grouped.filter(custom_filter).groupby("Category")["Values"].mean()


The transform() method is used to apply a transformation to your data after grouping. This is useful when you want to normalize or scale your data within each group. Here's an example:

# Define a custom transformation function
def custom_transform(x):
    return x / x.mean()
# Apply the transformation function to each group
result = grouped['Values'].transform(custom_transform)

Visualizing GroupBy Results

Visualizing the results of your GroupBy operations can help you better understand your data. You can use pandas' built-in plotting functions or other visualization libraries like Matplotlib or Seaborn to create various types of plots. Here's an example using pandas' plot() method:

import matplotlib.pyplot as plt
# Calculate the mean of each group
means = grouped['Values'].mean()
# Create a bar plot of the mean values
plt.ylabel('Mean Values')
plt.title('Mean Values by Category and Type')


In conclusion, pandas GroupBy is an essential tool for data analysis, offering a wealth of functionality for grouping, aggregating, filtering, and transforming your data. With this comprehensive guide, you'll be well-equipped to tackle a wide range of data analysis tasks and make your workflow more efficient. Don't forget to explore the official pandas documentation for even more information and examples.

More Pandas Tutorials: