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

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

参考：pandas groupby apply

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

1. GroupBy的基本概念

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

groupby是Pandas中用于数据分组的方法。它允许我们根据一个或多个列的值将数据分成不同的组，然后对每个组进行操作。这种操作通常包括聚合计算（如求和、平均值等）或应用自定义函数。

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

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')['salary'].mean()

print(grouped)

Output:

在这个例子中，我们按照’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)

Output:

在这个例子中，我们定义了一个salary_category函数，然后使用apply方法将这个函数应用到’salary’列的每个值上，创建了一个新的’salary_category’列。

3. GroupBy和Apply的结合使用

现在我们来看看如何将groupby和apply结合使用。这种组合可以让我们在每个分组上执行复杂的操作，而不仅仅是简单的聚合计算。

3.1 基本用法

让我们从一个简单的例子开始：

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]
})

# 定义一个自定义函数
def salary_diff_from_mean(group):
    return group['salary'] - group['salary'].mean()

# 使用groupby和apply
result = df.groupby('city').apply(salary_diff_from_mean)

print(result)

在这个例子中，我们定义了一个salary_diff_from_mean函数，它计算每个人的工资与所在城市平均工资的差值。然后，我们使用groupby('city').apply()将这个函数应用到每个城市组。

3.2 返回DataFrame

apply方法可以返回不同类型的对象。如果我们希望返回一个DataFrame，可以在自定义函数中构造并返回一个DataFrame：

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]
})

# 定义一个返回DataFrame的自定义函数
def city_stats(group):
    return pd.DataFrame({
        'avg_salary': [group['salary'].mean()],
        'max_age': [group['age'].max()],
        'min_age': [group['age'].min()],
        'count': [len(group)]
    })

# 使用groupby和apply
result = df.groupby('city').apply(city_stats).reset_index()

print(result)

这个例子中，我们定义了一个city_stats函数，它为每个城市计算平均工资、最大年龄、最小年龄和人数。函数返回一个包含这些统计信息的DataFrame。

3.3 多列分组

我们也可以按多个列进行分组：

import pandas as pd

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

# 定义一个自定义函数
def salary_comparison(group):
    return pd.DataFrame({
        'avg_salary': [group['salary'].mean()],
        'diff_from_overall': [group['salary'].mean() - df['salary'].mean()]
    })

# 使用groupby和apply，按城市和部门分组
result = df.groupby(['city', 'department']).apply(salary_comparison).reset_index()

print(result)

在这个例子中，我们按城市和部门进行分组，然后计算每个组的平均工资以及与整体平均工资的差异。

3.4 处理时间序列数据

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,
    'value': np.random.randn(len(dates))
})

# 定义一个计算移动平均的函数
def moving_average(group, window=7):
    return group.rolling(window=window).mean()

# 按月分组并计算7天移动平均
result = df.set_index('date').groupby(pd.Grouper(freq='M')).apply(moving_average)

print(result)

这个例子展示了如何使用groupby和apply来计算每个月内的7天移动平均。我们首先创建了一个包含全年每天数据的DataFrame，然后按月分组，并对每个月的数据应用移动平均函数。

3.5 自定义聚合函数

虽然Pandas提供了许多内置的聚合函数（如mean()、sum()等），但有时我们需要更复杂的聚合操作。这时，groupby和apply的组合就非常有用：

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]
})

# 定义一个自定义聚合函数
def custom_agg(group):
    return pd.Series({
        'salary_range': group['salary'].max() - group['salary'].min(),
        'age_variance': group['age'].var(),
        'salary_to_age_ratio': group['salary'].mean() / group['age'].mean()
    })

# 使用groupby和apply
result = df.groupby('city').apply(custom_agg)

print(result)

在这个例子中，我们定义了一个custom_agg函数，它计算每个城市的工资范围、年龄方差和平均工资与平均年龄的比率。这种方法允许我们执行任意复杂的聚合操作。

3.6 处理缺失值

groupby和apply的组合也可以用来处理缺失值：

import pandas as pd
import numpy as np

# 创建一个包含缺失值的示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, np.nan, 35, 28, np.nan],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'salary': [50000, 60000, np.nan, 55000, 65000]
})

# 定义一个处理缺失值的函数
def fill_missing(group):
    return group.fillna(group.mean())

# 使用groupby和apply
result = df.groupby('city').apply(fill_missing)

print(result)

在这个例子中，我们定义了一个fill_missing函数，它用每个城市的平均值填充缺失值。这种方法比简单地用整个DataFrame的平均值填充更合理，因为它考虑了不同城市的差异。

3.7 数据转换

groupby和apply的组合还可以用于复杂的数据转换操作：

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]
})

# 定义一个数据转换函数
def salary_percentile(group):
    group['salary_percentile'] = group['salary'].rank(pct=True)
    return group

# 使用groupby和apply
result = df.groupby('city').apply(salary_percentile)

print(result)

在这个例子中，我们定义了一个salary_percentile函数，它计算每个人在所在城市中的工资百分位数。这种操作可以帮助我们了解每个人的工资在其所在城市中的相对水平。

3.8 复杂条件筛选

groupby和apply的组合还可以用于复杂的条件筛选：

import pandas as pd

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

# 定义一个复杂筛选函数
def above_average_salary(group):
    avg_salary = group['salary'].mean()
    return group[group['salary'] > avg_salary]

# 使用groupby和apply
result = df.groupby('city').apply(above_average_salary)

print(result)

在这个例子中，我们定义了一个above_average_salary函数，它只保留工资高于所在城市平均工资的人。这种方法允许我们执行基于组内统计的复杂筛选操作。

3.9 创建新的特征

groupby和apply的组合还可以用来创建新的特征：

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]
})

# 定义一个创建新特征的函数
def create_features(group):
    group['salary_rank'] = group['salary'].rank(ascending=False)
    group['age_normalized'] = (group['age'] - group['age'].mean()) / group['age'].std()
    return group

# 使用groupby和apply
result = df.groupby('city').apply(create_features)

print(result)

在这个例子中，我们定义了一个create_features函数，它为每个城市创建了两个新特征：工资排名和标准化后的年龄。这种方法允许我们创建基于组内统计的复杂特征。### 3.10 处理分组内的时间序列数据

当处理包含时间信息的数据时，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': np.tile(dates, 3),
    'city': np.repeat(['New York', 'London', 'Paris'], len(dates)),
    'sales': np.random.randint(100, 1000, len(dates) * 3)
})

# 定义一个计算累积销售额的函数
def cumulative_sales(group):
    group = group.sort_values('date')
    group['cumulative_sales'] = group['sales'].cumsum()
    return group

# 使用groupby和apply
result = df.groupby('city').apply(cumulative_sales)

print(result.head(10))

在这个例子中，我们创建了一个包含每个城市每天销售额的DataFrame。然后，我们定义了一个cumulative_sales函数，它计算每个城市的累积销售额。这种方法允许我们对每个城市的时间序列数据进行独立的处理。

3.11 处理多层索引

当使用多个列进行分组时，groupby会创建一个多层索引。我们可以利用apply来处理这种复杂的数据结构：

import pandas as pd

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

# 定义一个处理多层索引的函数
def salary_diff(group):
    overall_mean = df['salary'].mean()
    dept_mean = df[df['department'] == group.name[0]]['salary'].mean()
    city_mean = df[df['city'] == group.name[1]]['salary'].mean()
    return pd.Series({
        'diff_from_overall': group['salary'].mean() - overall_mean,
        'diff_from_dept': group['salary'].mean() - dept_mean,
        'diff_from_city': group['salary'].mean() - city_mean
    })

# 使用groupby和apply
result = df.groupby(['department', 'city']).apply(salary_diff)

print(result)

在这个例子中，我们按部门和城市进行分组，然后计算每个组的平均工资与整体平均工资、部门平均工资和城市平均工资的差异。这种方法允许我们处理多层次的数据结构，并进行复杂的比较分析。

3.12 自定义索引

在使用groupby和apply时，我们可以自定义结果的索引：

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]
})

# 定义一个返回自定义索引的函数
def custom_index(group):
    result = pd.DataFrame({
        'avg_salary': [group['salary'].mean()],
        'avg_age': [group['age'].mean()]
    })
    result.index = [f"{group.name}_stats"]
    return result

# 使用groupby和apply
result = df.groupby('city').apply(custom_index)

print(result)

在这个例子中，我们定义了一个custom_index函数，它不仅计算每个城市的平均工资和平均年龄，还为结果创建了一个自定义的索引。这种方法可以帮助我们创建更具可读性和意义的结果索引。

3.13 处理大型数据集

当处理大型数据集时，groupby和apply的组合可能会变得较慢。在这种情况下，我们可以考虑使用groupby的agg方法或者Pandas的transform方法来提高性能：

import pandas as pd
import numpy as np

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

# 使用agg方法
result_agg = df.groupby('group').agg({
    'value': ['mean', 'std', 'count']
})

# 使用transform方法
df['value_normalized'] = df.groupby('group')['value'].transform(lambda x: (x - x.mean()) / x.std())

print(result_agg)
print(df.head())

Output:

在这个例子中，我们首先使用agg方法同时计算了每个组的平均值、标准差和计数。然后，我们使用transform方法对每个组的值进行了标准化。这两种方法通常比使用apply更快，特别是在处理大型数据集时。

3.14 处理分类数据

groupby和apply的组合也可以用于处理分类数据：

import pandas as pd

# 创建一个包含分类数据的示例DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'education': ['Bachelor', 'Master', 'PhD', 'Bachelor', 'Master'],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 将education列转换为分类类型
df['education'] = pd.Categorical(df['education'], categories=['Bachelor', 'Master', 'PhD'], ordered=True)

# 定义一个处理分类数据的函数
def education_stats(group):
    return pd.Series({
        'avg_salary': group['salary'].mean(),
        'min_age': group['age'].min(),
        'max_age': group['age'].max()
    })

# 使用groupby和apply
result = df.groupby('education').apply(education_stats)

print(result)

在这个例子中，我们首先将’education’列转换为有序的分类类型。然后，我们定义了一个education_stats函数来计算每个教育水平组的统计信息。这种方法允许我们更好地处理和分析分类数据。

3.15 处理字符串数据

groupby和apply的组合也可以用于处理字符串数据：

import pandas as pd

# 创建一个包含字符串数据的示例DataFrame
df = pd.DataFrame({
    'name': ['Alice Smith', 'Bob Johnson', 'Charlie Brown', 'David Lee', 'Eve Wilson'],
    'email': ['alice@pandasdataframe.com', 'bob@pandasdataframe.com', 'charlie@pandasdataframe.com', 'david@pandasdataframe.com', 'eve@pandasdataframe.com'],
    'department': ['Sales', 'IT', 'Sales', 'IT', 'HR']
})

# 定义一个处理字符串的函数
def process_strings(group):
    group['last_name'] = group['name'].apply(lambda x: x.split()[-1])
    group['email_domain'] = group['email'].apply(lambda x: x.split('@')[-1])
    return group

# 使用groupby和apply
result = df.groupby('department').apply(process_strings)

print(result)

在这个例子中，我们定义了一个process_strings函数，它从名字中提取姓氏，并从电子邮件地址中提取域名。这种方法允许我们对每个部门的字符串数据进行复杂的处理。

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],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'salary': [50000, 60000, 70000, 55000, 65000]
})

# 使用lambda函数
result = df.groupby('city').apply(lambda x: x['salary'].max() - x['salary'].min())

print(result)

这个例子计算了每个城市的工资范围（最高工资减去最低工资）。使用lambda函数可以使代码更简洁，特别是对于简单的操作。

4.2 处理大型数据集的性能问题

当处理大型数据集时，groupby和apply的组合可能会导致性能问题。在这种情况下，可以考虑使用其他方法，如agg、transform或numba来优化性能：

import pandas as pd
import numpy as np
from numba import jit

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

# 使用numba优化的函数
@jit(nopython=True)
def fast_mean(values):
    return values.mean()

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

print(result)

在这个例子中，我们使用numba库的jit装饰器来优化我们的自定义函数。这可以显著提高大型数据集的处理速度。

4.3 处理多列操作

有时，我们可能需要在apply函数中处理多个列。这可以通过在函数中访问整个组来实现：

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],
    'bonus': [5000, 7000, 8000, 6000, 7500]
})

# 定义一个处理多列的函数
def total_compensation(group):
    return pd.Series({
        'avg_total': (group['salary'] + group['bonus']).mean(),
        'max_total': (group['salary'] + group['bonus']).max()
    })

# 使用groupby和apply
result = df.groupby('city').apply(total_compensation)

print(result)

在这个例子中，我们定义了一个total_compensation函数，它计算每个城市的平均总薪酬和最高总薪酬（工资加奖金）。这展示了如何在apply函数中处理多个列。

5. 结论

Pandas的groupby和apply方法的组合使用为数据分析提供了强大而灵活的工具。通过这种方法，我们可以执行复杂的分组操作、自定义聚合、数据转换等各种任务。从简单的统计计算到复杂的时间序列分析，从处理数值数据到处理字符串和分类数据，groupby和apply的组合几乎可以满足所有的数据处理需求。

然而，在使用这种方法时，我们也需要注意一些潜在的陷阱，特别是在处理大型数据集时的性能问题。在这种情况下，可以考虑使用其他方法如agg、transform或借助外部库如numba来优化性能。

总的来说，掌握groupby和apply的使用可以大大提高我们处理和分析数据的能力，使我们能够更加灵活和高效地探索数据，发现数据中的模式和洞见。随着数据分析在各个领域的重要性不断增加，这种技能将变得越来越重要。