Pandas is a powerful and versatile Python library for data manipulation and analysis. One of its most useful functions is the ability to group data by one or more columns and then apply various aggregate functions to the subsets of data. In this article, we will explore how to use the groupby() function in pandas to aggregate multiple columns at once.

First, let's create a sample DataFrame to work with:

```
import pandas as pd
data = {'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'age': [25, 30, 35, 40, 45],
'income': [50000, 60000, 65000, 70000, 75000],
'expenses': [20000, 22000, 25000, 27000, 30000]}
df = pd.DataFrame(data)
```

This DataFrame has four columns: 'name', 'age', 'income', and 'expenses'. Now, let's say we want to group the data by the 'name' column and calculate the mean, sum, and maximum of the 'income' and 'expenses' columns for each group. We can do this using the groupby() function and the aggregate() function:

```
grouped = df.groupby('name').agg({'income': ['mean', 'sum', 'max'], 'expenses': ['mean', 'sum', 'max']})
```

The groupby() function takes one or more column names as input and returns a DataFrameGroupBy object. The aggregate() function is then applied to this object, taking a dictionary as input where the keys are the column names and the values are the aggregate functions to be applied. In this case, we are applying the mean, sum, and max functions to the 'income' and 'expenses' columns.

The resulting DataFrame will have a hierarchical column index, with the first level representing the column name, and the second level representing the aggregate function.

```
income expenses
mean sum max mean sum max
name
Alice 50000.000000 50000 50000 20000.000000 20000 20000
Bob 60000.000000 60000 60000 22000.000000 22000 22000
Charlie 65000.000000 65000 65000 25000.000000 25000 25000
David 70000.000000 70000 70000 27000.000000 27000 27000
Eve 75000.000000 75000 75000 30000.000000 30000 30000
```

If you don't want to have the hierarchical column index, use `.reset_index()`

function after the aggregate function.

Another way to group by multiple columns, is to pass multiple column names to the groupby() function:

```
grouped = df.groupby(['name', 'age']).agg({'income': ['mean', 'sum', 'max'], 'expenses': ['mean', 'sum', 'max']})
```

In this case, the data will be grouped by both the 'name' and 'age' columns. The resulting DataFrame will have a multi-level index, with the first level representing the 'name' column, the second level representing the 'age' column, and the third level representing the aggregate function.

In both examples we have used the aggregate() function to

Another useful function in pandas when working with groupby is the apply() function. This function allows you to apply a custom function to each group of data. For example, let's say we want to calculate the percentage of expenses compared to income for each group:

```
def expense_percentage(group):
return group['expenses'].sum() / group['income'].sum()
grouped = df.groupby('name').apply(expense_percentage)
```

Here, we define a function expense_percentage that takes a group of data as input and calculates the ratio of expenses to income. We then apply this function to each group using the apply() function. The resulting Series will have the group names as the index and the calculated expense percentage as the values.

Another useful function when working with groupby is the transform() function. This function is similar to the apply() function, but it applies a function to each element of the group rather than to the whole group. For example, let's say we want to standardize the income column for each group:

```
def standardize(x):
return (x - x.mean()) / x.std()
df['income_std'] = df.groupby('name')['income'].transform(standardize)
```

Here, we define a function standardize that takes a series as input and standardize it. Then we use transform function to apply it to each element of the 'income' column. The resulting column 'income_std' will contain the standardized values of income for each group.

The above are some examples of how to use the groupby() function in pandas to aggregate multiple columns and apply custom functions to groups of data. With these tools, you can easily manipulate and analyze large sets of data in a flexible and efficient way.

## Popular questions

- How can I group data by multiple columns in pandas?

Answer: You can group data by multiple columns by passing a list of column names to the groupby() function. For example:

```
df.groupby(['name', 'year'])['income'].sum()
```

This will group the data by both the 'name' and 'year' columns, and calculate the sum of the 'income' column for each group.

- How can I apply multiple aggregation functions to different columns at the same time?

Answer: You can use the agg() function to apply multiple aggregation functions to different columns at the same time. For example:

```
df.groupby('name')['income', 'expenses'].agg({'income': 'sum', 'expenses': 'mean'})
```

This will group the data by the 'name' column, and calculate the sum of the 'income' column and the mean of the 'expenses' column for each group.

- How can I apply a custom function to groups of data?

Answer: You can use the apply() function to apply a custom function to groups of data. For example:

```
def expense_percentage(group):
return group['expenses'].sum() / group['income'].sum()
df.groupby('name').apply(expense_percentage)
```

This will group the data by the 'name' column, and apply the expense_percentage function to each group.

- How can I create a new column based on a groupby operation?

Answer: You can use the transform() function to create a new column based on a groupby operation. For example:

```
df['income_std'] = df.groupby('name')['income'].transform(lambda x: (x - x.mean()) / x.std())
```

This will group the data by the 'name' column, standardize the 'income' column for each group and create a new column 'income_std' with the standardized values.

- How can I use the groupby() function in combination with other data manipulation functions like filter() and transform()?

Answer: You can chain the groupby() function with other data manipulation functions like filter() and transform() to perform complex operations on your data. For example:

```
df.groupby('name').filter(lambda x: x['income'].mean() > 100)
df.groupby('name').transform(lambda x: x - x.min())
```

This will group the data by 'name' column, filter out the groups whose mean income is less than 100 and transform the data to subtract the minimum value of each group.

### Tag

Data-aggregation