当前位置：极客教程 > Pandas > Pandas 问答 > Pandas GroupBy Apply：强大的数据分组和应用函数技巧

Pandas GroupBy Apply：强大的数据分组和应用函数技巧

Pandas GroupBy Apply：强大的数据分组和应用函数技巧

参考：pandas groupby apply

Pandas是Python中最流行的数据处理库之一，它提供了丰富的功能来处理结构化数据。其中，groupby和apply方法的组合使用是一个非常强大的工具，可以帮助我们对数据进行分组操作并应用自定义函数。本文将深入探讨Pandas中groupby和apply的使用方法、常见场景以及一些高级技巧。

1. GroupBy的基本概念

在开始讨论groupby和apply的组合使用之前，我们先来了解一下groupby的基本概念。

groupby是Pandas中用于数据分组的方法。它允许我们根据一个或多个列的值将数据分成不同的组，然后对每个组separately应用操作。这种分组操作在数据分析中非常常见，比如计算每个类别的平均值、找出每个组的最大值等。

让我们看一个简单的例子：

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 按城市分组并计算平均年龄和薪资
grouped = df.groupby('city').agg({'age': 'mean', 'salary': 'mean'})
print(grouped)
Python

Output:

Pandas GroupBy Apply：强大的数据分组和应用函数技巧

在这个例子中，我们创建了一个包含姓名、年龄、城市和薪资信息的DataFrame。然后，我们使用groupby('city')按城市进行分组，并计算每个城市的平均年龄和薪资。

2. Apply方法简介

apply方法是Pandas中另一个强大的工具，它允许我们将自定义函数应用于DataFrame或Series的行或列。当与groupby结合使用时，apply方法可以在每个分组上执行复杂的操作。

下面是一个简单的apply方法的例子：

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 定义一个自定义函数
def salary_category(salary):
    if salary < 55000:
        return 'Low'
    elif salary < 65000:
        return 'Medium'
    else:
        return 'High'

# 使用apply方法应用自定义函数
df['salary_category'] = df['salary'].apply(salary_category)
print(df)
Python

Output:

Pandas GroupBy Apply：强大的数据分组和应用函数技巧

在这个例子中，我们定义了一个salary_category函数，根据薪资水平将其分为低、中、高三个类别。然后，我们使用apply方法将这个函数应用到’salary’列上，创建了一个新的’salary_category’列。

3. GroupBy和Apply的结合使用

现在，让我们来看看如何将groupby和apply结合使用。这种组合可以让我们在每个分组上执行复杂的操作，非常适合处理需要自定义逻辑的分组计算。

3.1 基本用法

以下是一个基本的groupby和apply结合使用的例子：

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000]
})

# 定义一个自定义函数
def top_salary(group):
    return group.loc[group['salary'].idxmax()]

# 使用groupby和apply
result = df.groupby('department').apply(top_salary)
print(result)
Python

在这个例子中，我们首先创建了一个包含员工姓名、部门和薪资信息的DataFrame。然后，我们定义了一个top_salary函数，该函数返回每个组中薪资最高的员工信息。最后，我们使用groupby('department').apply(top_salary)来找出每个部门薪资最高的员工。

3.2 多列分组

groupby可以根据多个列进行分组。这在处理复杂的数据结构时非常有用。让我们看一个例子：

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'location': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000]
})

# 定义一个自定义函数
def avg_salary(group):
    return pd.Series({
        'avg_salary': group['salary'].mean(),
        'count': len(group)
    })

# 使用groupby和apply
result = df.groupby(['department', 'location']).apply(avg_salary)
print(result)
Python

在这个例子中，我们按部门和地点进行分组，然后计算每个组的平均薪资和员工数量。这种多列分组可以帮助我们更细致地分析数据。

3.3 处理时间序列数据

groupby和apply的组合在处理时间序列数据时也非常有用。以下是一个例子：

import pandas as pd
import numpy as np

# 创建一个示例时间序列DataFrame
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
df = pd.DataFrame({
    'date': dates,
    'sales': np.random.randint(100, 1000, size=len(dates))
})

# 定义一个自定义函数计算7天移动平均
def moving_average(group):
    return group['sales'].rolling(window=7).mean()

# 使用groupby和apply
df['month'] = df['date'].dt.to_period('M')
result = df.groupby('month').apply(moving_average)
print(result.head())
Python

在这个例子中，我们创建了一个包含全年每日销售数据的DataFrame。然后，我们定义了一个函数来计算7天移动平均。最后，我们按月分组并应用这个函数，得到每个月内的7天移动平均销售额。

3.4 自定义聚合函数

groupby和apply的组合还允许我们创建复杂的自定义聚合函数。这在标准聚合函数无法满足需求时特别有用。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000],
    'bonus': [5000, 7000, 8000, 5500, 7500, 9000]
})

# 定义一个自定义聚合函数
def custom_agg(group):
    return pd.Series({
        'avg_salary': group['salary'].mean(),
        'total_bonus': group['bonus'].sum(),
        'salary_range': group['salary'].max() - group['salary'].min()
    })

# 使用groupby和apply
result = df.groupby('department').apply(custom_agg)
print(result)
Python

在这个例子中，我们定义了一个自定义聚合函数，它计算每个部门的平均薪资、总奖金和薪资范围。这种方法允许我们在一次操作中执行多个复杂的计算。

3.5 处理缺失值

groupby和apply的组合也可以用来处理缺失值。以下是一个例子：

import pandas as pd
import numpy as np

# 创建一个包含缺失值的示例DataFrame
df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B', 'C', 'C'],
    'value': [1, np.nan, 3, np.nan, 5, 6]
})

# 定义一个函数来填充缺失值
def fill_missing(group):
    return group.fillna(group.mean())

# 使用groupby和apply
result = df.groupby('group').apply(fill_missing)
print(result)
Python

Output:

Pandas GroupBy Apply：强大的数据分组和应用函数技巧

在这个例子中，我们创建了一个包含缺失值的DataFrame。然后，我们定义了一个函数，用每个组的平均值来填充该组内的缺失值。最后，我们使用groupby和apply来应用这个函数。

3.6 计算累积统计量

groupby和apply的组合还可以用来计算累积统计量。这在分析时间序列数据时特别有用。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'date': pd.date_range(start='2023-01-01', periods=10),
    'group': ['A', 'B'] * 5,
    'value': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
})

# 定义一个函数来计算累积和
def cumulative_sum(group):
    return group.sort_values('date').cumsum()

# 使用groupby和apply
result = df.groupby('group').apply(cumulative_sum)
print(result)
Python

在这个例子中，我们创建了一个包含日期、分组和值的DataFrame。然后，我们定义了一个函数来计算累积和。最后，我们使用groupby和apply来计算每个组内的累积和。

3.7 动态创建新列

groupby和apply的组合还可以用来动态创建新列。这在需要基于分组信息创建新特征时非常有用。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000]
})

# 定义一个函数来创建新列
def create_rank(group):
    group['salary_rank'] = group['salary'].rank(ascending=False)
    return group

# 使用groupby和apply
result = df.groupby('department').apply(create_rank)
print(result)
Python

在这个例子中，我们定义了一个函数来为每个部门内的员工创建薪资排名。然后，我们使用groupby和apply来应用这个函数，从而在原DataFrame中添加了一个新的’salary_rank’列。

3.8 复杂的条件筛选

groupby和apply的组合还可以用于执行复杂的条件筛选操作。这在需要基于组内的某些条件来筛选数据时非常有用。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000],
    'experience': [3, 5, 7, 2, 4, 6]
})

# 定义一个函数来筛选数据
def filter_top_experience(group):
    return group[group['experience'] == group['experience'].max()]

# 使用groupby和apply
result = df.groupby('department').apply(filter_top_experience)
print(result)
Python

在这个例子中，我们定义了一个函数来筛选每个部门中经验最丰富的员工。然后，我们使用groupby和apply来应用这个函数，从而得到每个部门经验最丰富的员工信息。

3.9 处理多层索引

当使用多个列进行分组时，groupby会创建一个多层索引。apply方法可以很好地处理这种多层索引的数据。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT', 'Finance'],
    'location': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris'],
    'salary': [50000, 60000, 70000, 55000, 65000, 75000]
})

# 定义一个函数来处理多层索引
def process_group(group):
    return pd.Series({
        'avg_salary': group['salary'].mean(),
        'max_salary': group['salary'].max(),
        'min_salary': group['salary'].min()
    })

# 使用groupby和apply
result = df.groupby['department', 'location']).apply(process_group)
print(result)
Python

在这个例子中，我们按部门和地点进行分组，然后应用一个函数来计算每个组的平均薪资、最高薪资和最低薪资。结果是一个具有多层索引的DataFrame，其中第一层是部门，第二层是地点。

3.10 处理大型数据集

当处理大型数据集时，groupby和apply的组合可能会变得较慢。在这种情况下，我们可以考虑使用groupby的agg方法或者Pandas的transform方法来提高性能。但是，对于一些无法用这些方法实现的复杂操作，apply仍然是一个强大的工具。

import pandas as pd
import numpy as np

# 创建一个较大的示例DataFrame
np.random.seed(0)
df = pd.DataFrame({
    'group': np.random.choice(['A', 'B', 'C'], size=100000),
    'value': np.random.randn(100000)
})

# 定义一个函数来计算每组的中位数和标准差
def custom_stats(group):
    return pd.Series({
        'median': group['value'].median(),
        'std': group['value'].std()
    })

# 使用groupby和apply
result = df.groupby('group').apply(custom_stats)
print(result)
Python

在这个例子中，我们创建了一个包含10万行数据的DataFrame。然后，我们定义了一个函数来计算每个组的中位数和标准差。虽然这个操作可能会比使用内置的聚合函数慢一些，但它展示了apply方法在处理大型数据集时的灵活性。

4. 高级技巧和注意事项

4.1 使用lambda函数

有时，我们可能只需要一个简单的操作，这时使用lambda函数可以让代码更加简洁。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 使用lambda函数
result = df.groupby('name').apply(lambda x: x['salary'] / x['age'])
print(result)
Python

在这个例子中，我们使用lambda函数计算每个人的薪资年龄比。这种方法适用于简单的操作，但对于复杂的逻辑，还是建议使用命名函数以提高代码的可读性。

4.2 处理返回值

apply方法的返回值可以是多种类型，包括Series、DataFrame或标量值。Pandas会根据返回值的类型自动处理结果。

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'department': ['HR', 'IT', 'Finance', 'HR', 'IT'],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 返回Series
def return_series(group):
    return pd.Series({'avg_salary': group['salary'].mean(), 'count': len(group)})

# 返回DataFrame
def return_dataframe(group):
    return pd.DataFrame({'avg_salary': [group['salary'].mean()], 'count': [len(group)]})

# 返回标量
def return_scalar(group):
    return group['salary'].mean()

# 使用不同的返回类型
result_series = df.groupby('department').apply(return_series)
result_dataframe = df.groupby('department').apply(return_dataframe)
result_scalar = df.groupby('department').apply(return_scalar)

print("Series result:")
print(result_series)
print("\nDataFrame result:")
print(result_dataframe)
print("\nScalar result:")
print(result_scalar)
Python

这个例子展示了apply方法如何处理不同类型的返回值。理解这一点对于正确使用apply方法非常重要。

4.3 性能考虑

虽然groupby和apply的组合非常强大，但在处理大型数据集时可能会遇到性能问题。在这种情况下，可以考虑以下几点：

  1. 尽可能使用内置的聚合函数（如mean、sum等）而不是自定义函数。
  2. 如果可能，使用transform方法代替apply。
  3. 考虑使用numba或Cython来优化自定义函数的性能。
import pandas as pd
import numpy as np
from numba import jit

# 创建一个大型示例DataFrame
df = pd.DataFrame({
    'group': np.random.choice(['A', 'B', 'C'], size=1000000),
    'value': np.random.randn(1000000)
})

# 使用numba优化的函数
@jit(nopython=True)
def optimized_std(x):
    return np.std(x)

# 使用优化后的函数
result = df.groupby('group')['value'].apply(optimized_std)
print(result)
Python

这个例子展示了如何使用numba来优化自定义函数的性能。对于大型数据集，这种方法可以显著提高计算速度。

5. 总结

Pandas的groupby和apply方法的组合为数据分析提供了强大而灵活的工具。通过本文的介绍和示例，我们可以看到这种组合可以用于各种复杂的数据处理任务，从简单的分组聚合到复杂的自定义操作。

关键点总结：

  1. groupby允许我们根据一个或多个列的值将数据分组。
  2. apply方法可以将自定义函数应用于每个分组。
  3. 这种组合可以用于处理时间序列数据、创建自定义聚合函数、处理缺失值、计算累积统计量等。
  4. 在处理大型数据集时，需要考虑性能问题，可以使用内置函数或优化技术来提高效率。
  5. 理解apply方法的返回值处理对于正确使用这个功能非常重要。

通过掌握groupby和apply的使用，数据分析师和开发者可以更加灵活地处理各种复杂的数据分析任务，提高工作效率和数据处理能力。

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Pandas 精品教程

登录

找回密码？

注册