数据分析 — Pandas 分组聚合

最新推荐文章于 2024-04-25 21:07:42 发布
最新推荐文章于 2024-04-25 21:07:42 发布
阅读量1.5k 收藏 21
点赞数 24
分类专栏： 数据分析 文章标签： 数据分析 pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muyuhen/article/details/136116810
版权

目录

一、函数应用和映射

1、apply

pandas.apply() 是 Pandas 库中的一个函数，用于在 DataFrame 或 Series 上应用自定义函数。这个函数可以沿着指定的轴（行或列）逐行或逐列地应用函数，从而实现对数据的定制化操作。

参数：

  • func（必需）：这是要应用的函数，可以是一个 Python 函数、lambda 函数或可调用对象。这个函数将应用于 Series 或 DataFrame 的每个元素或行/列，具体取决于 axis 参数的设置。

  • axis（可选）：指定函数应用的轴方向。有两个选项：

    • axis=0（默认值）：将函数应用于每一列，即按列方向操作。

    • axis=1：将函数应用于每一行，即按行方向操作。

  • raw（可选）：一个布尔值，用于控制是否将数据以 NumPy 数组的形式传递给函数。有两个选项：

    • raw=False（默认值）：表示将数据以 Series 或 DataFrame 的形式传递给函数。
    • raw=True：表示数据以 NumPy 数组形式传递给函数，这在某些情况下可能提高性能。

  • result_type（可选）：指定函数的返回类型。有两个选项：

    • expand（默认值）：如果函数返回的是 Series，则将其扩展为 DataFrame。
    • reduce：如果函数返回的是标量（如一个数字），则返回一个标量；如果返回的是 Series，则返回一个 Series。

  • args（可选）：一个元组，包含传递给函数的额外参数。这可以用来向函数传递额外的参数。

  • **kwds（可选）：关键字参数，用于传递给函数的额外关键字参数。

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
print("原df\n", df)
# 原df
#     A   B
# 0  1  10
# 1  2  20
# 2  3  30
# 3  4  40
# 4  5  50

# 使用 lambda 函数将每个元素加倍
df['A2'] = df['A'].apply(lambda x: x * 2)
print("A列2倍处理后的df\n", df)
# A列2倍处理后的df
#     A   B  A2
# 0  1  10   2
# 1  2  20   4
# 2  3  30   6
# 3  4  40   8
# 4  5  50  10

# 增加新列 Row_Sum，值为A列和B列对应位置相加的结果
def row_sum(row):
    return row['A'] + row['B']
df['Row_Sum'] = df.apply(row_sum, axis=1)
print("增加AB两列和后的df\n", df)
# 增加AB两列和后的df
#     A   B  A2  Row_Sum
# 0  1  10   2       11
# 1  2  20   4       22
# 2  3  30   6       33
# 3  4  40   8       44
# 4  5  50  10       55

2、map

pandas.map() 是 Pandas 库中的一个方法，主要用于对 Series 中的每个元素应用一个函数或一个字典，将每个元素映射到另一个值上。它可以用于进行元素级的转换，从而创建新的 Series。

参数：

  • arg（必需）：这是映射函数、字典或其它可映射对象，用于将 Series 中的元素映射到新的值。可以是以下几种类型：
    • 一个函数：将应用于 Series 中的每个元素，函数的返回值将作为新的值。
    • 一个字典：将 Series 中的值与字典中的键进行匹配，并将对应的值用作新的值。
    • 一个 Series 或其它可映射的 Pandas 对象：将 Series 中的值与可映射对象中的索引或标签匹配，并将对应的值用作新的值。
  • na_action (可选)：指定对于 Series 中的缺失值如何处理。有两个选项：
    • ignore（默认值）：忽略缺失值，不进行映射，将缺失值保留不变。
    • raise：如果 Series 中存在缺失值，则引发异常。
import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 Series
data = {'A': ['apple', 'banana', 'cherry', 'date']}
s = pd.Series(data['A'])
# 使用字典映射元素到新的值
dict1 = {'apple': 'fruit', 'banana': 'fruit', 'cherry': 'fruit'}
s_mapped = s.map(dict1)
print(s_mapped)
# 0    fruit
# 1    fruit
# 2    fruit
# 3      NaN
# dtype: object

# 使用函数映射元素到新的值
def func(x):
    if x in ['apple', 'banana', 'cherry']:
        return 'fruit'
    else:
        return 'other'

s_mapped2= s.map(func)
print(s_mapped2)
# 0    fruit
# 1    fruit
# 2    fruit
# 3    other
# dtype: object

二、汇总和描述统计

1、计算平均值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算平均值
mean_A = df['A'].mean()
mean_B = df['B'].mean()
print(f'A列平均值: {mean_A}')  # A列平均值: 3.0
print(f'B列平均值: {mean_B}')  # B列平均值: 30.0

2、计算中位数

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算中位数
median_A = df['A'].median()
median_B = df['B'].median()
print(f'A列中位数: {median_A}')  # A列中位数: 3.0
print(f'B列中位数: {median_B}')  # B列中位数: 30.0

3、计算总和

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算总和
sum_A = df['A'].sum()
sum_B = df['B'].sum()
print(f'A列求和: {sum_A}')  # A列求和: 15
print(f'B列求和: {sum_B}')  # B列求和: 150

4、找到最小值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 找到最小值
min_A = df['A'].min()
min_B = df['B'].min()
print(f'A列最小值: {min_A}')  # A列最小值: 1
print(f'B列最小值: {min_B}')  # B列最小值: 10

5、找到最大值

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 找到最大值
max_A = df['A'].max()
max_B = df['B'].max()
print(f'A列最大值: {max_A}')  # A列最大值: 5
print(f'B列最大值: {max_B}')  # B列最大值: 50

6、计算标准差

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算标准差
std_A = df['A'].std()
std_B = df['B'].std()
print(f'A列标准差: {std_A}')  # 标准差A: 1.5811388300841898
print(f'B列标准差: {std_B}')  # 标准差B: 15.811388300841896

7、计算方差

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算方差
var_A = df['A'].var()
var_B = df['B'].var()
print(f'A列方差: {var_A}')  # A列方差: 2.5
print(f'B列方差: {var_B}')  # B列方差: 250.0

8、计算非空值的数量

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算非空值的数量
count_A = df['A'].count()
count_B = df['B'].count()
print(f'A列非空值数量: {count_A}')  # A列非空值数量: 5
print(f'B列非空值数量: {count_B}')  # B列非空值数量: 5

9、生成摘要统计信息

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 生成摘要统计信息
summary_A = df['A'].describe()
summary_B = df['B'].describe()
print(f'A列概览:\n{summary_A}')
# A列概览:
# count    5.000000
# mean     3.000000
# std      1.581139
# min      1.000000
# 25%      2.000000
# 50%      3.000000
# 75%      4.000000
# max      5.000000
# Name: A, dtype: float64
print(f'B列概览:\n{summary_B}')
# B列概览:
# count     5.000000
# mean     30.000000
# std      15.811388
# min      10.000000
# 25%      20.000000
# 50%      30.000000
# 75%      40.000000
# max      50.000000
# Name: B, dtype: float64

10、计算唯一值的频率

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
# 计算唯一值的频率
value_counts_A = df['A'].value_counts()
value_counts_B = df['B'].value_counts()
print(f'A列各值计数:\n{value_counts_A}')
# A列各值计数:
# A
# 1    1
# 2    1
# 3    1
# 4    1
# 5    1
# Name: count, dtype: int64
print(f'B列各值计数:\n{value_counts_B}')
# B列各值计数:
# B
# 10    1
# 20    1
# 30    1
# 40    1
# 50    1
# Name: count, dtype: int64

三、str 属性

作用是对元素级的数据（单元格数据）进行处理，能处理的是字符串。

1、str.len()

计算每个字符串的长度

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
df['name_length'] = df['name'].str.len()
print(df)
#       name  name_length
# 0    Alice            5
# 1      Bob            3
# 2  Charlie            7

2、str.lower() 和 str.upper()

str.lower()：将字符串转换为小写

str.upper()：将字符串转换为大写

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
df['name_lower'] = df['name'].str.lower()
df['name_upper'] = df['name'].str.upper()
print(df)
#       name name_lower name_upper
# 0    Alice      alice      ALICE
# 1      Bob        bob        BOB
# 2  Charlie    charlie    CHARLIE

3、str.replace()

替换字符串中的子字符串

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
df['name_replaced'] = df['name'].str.replace('a', 'X')
print(df)
#       name name_replaced
# 0    Alice         Alice
# 1      Bob           Bob
# 2  Charlie       ChXrlie

4、str.strip()、str.lstrip() 和 str.rstrip()

str.strip()：删除字符串两侧的空格

str.lstrip()：删除字符串左侧的空格

str.rstrip()：删除字符串右侧的空格

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['  Alice  ', '  Bob  ', '  Charlie  ']}
df = pd.DataFrame(data)
df['name_strip'] = df['name'].str.strip()
df['name_lstrip'] = df['name'].str.lstrip()
df['name_rstrip'] = df['name'].str.rstrip()
print(df)
#           name name_strip name_lstrip name_rstrip
# 0      Alice        Alice     Alice         Alice
# 1        Bob          Bob       Bob           Bob
# 2    Charlie      Charlie   Charlie       Charlie

5、str.split()

拆分字符串为列表

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
df['name_split'] = df['name'].str.split(' ')
print(df)
#       name name_split
# 0    Alice    [Alice]
# 1      Bob      [Bob]
# 2  Charlie  [Charlie]

6、str.startswith() 和 str.endswith()

str.startswith()：检查字符串是否以特定前缀开头

str.endswith()：检查字符串是否以特定后缀开头

import pandas as pd  # 导入 Pandas 库并使用别名 pd
# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie']}
df = pd.DataFrame(data)
df['name_startswith'] = df['name'].str.startswith('A')
df['name_endswith'] = df['name'].str.endswith('e')
print(df)
#       name  name_startswith  name_endswith
# 0    Alice             True           True
# 1      Bob            False          False
# 2  Charlie            False           True

7、str.count()

用于计算字符串中非空元素的方法

import pandas as pd  # 导入 Pandas 库并使用别名 pd

# 创建一个示例 DataFrame
data = {'name': ['Alice', 'Bob', 'Charlie', None, 'David']}
df = pd.DataFrame(data)
count_substring = df['name'].str.count('a')
print(count_substring)
# 0    0.0
# 1    0.0
# 2    1.0
# 3    NaN
# 4    1.0
# Name: name, dtype: float64
print(count_substring.sum())  # 2.0

四、分组聚合

groupby() 是 Pandas 中一个方法，用于将数据按照一个或多个列的值分组，然后对每个分组应用聚合函数。

参数：

  • by（必需）：指定分组的列名或列名的列表。可以是单个列名的字符串，也可以是列名的列表，以按多列分组。这是 groupby() 方法的关键参数。
  • axis（可选）：指定分组的轴方向，有两个选项：
    • axis=0（默认值）：按行分组。
    • axis=1：按列分组。
  • level（可选）：如果输入 DataFrame 包含多层索引，则可以指定要分组的索引级别。
  • as_index（可选）：默认情况下，groupby() 结果的分组键会成为结果 DataFrame 的索引。设置 as_index=False 可以防止这种情况发生，分组键将保留为列而不是索引。
  • sort（可选）：默认情况下，分组键会根据分组键的值进行排序。设置 sort=False 可以禁用排序，可能提高性能。
import pandas as pd  # 导入 Pandas 库并使用别名 pd

# 创建一个示例 DataFrame
data = {'Category': ['A', 'B', 'A', 'B', 'A'],'Value': [10, 20, 15, 25, 30]}
df = pd.DataFrame(data)
# 按 Category 列分组，并计算每个分组的平均值
grouped = df.groupby(by='Category')
res1 = grouped.mean()
print(res1)
#               Value
# Category
# A         18.333333
# B         22.500000

# 使用多列进行分组
grouped = df.groupby(by=['Category', 'Value'])
# 聚合求和
res2 = grouped.sum()
print(res2)
# Empty DataFrame
# Columns: []
# Index: [(A, 10), (A, 15), (A, 30), (B, 20), (B, 25)]

# 使用自定义聚合函数
def custom_agg(x):
  return x.max() - x.min()
res3 = df.groupby(by='Category').agg(custom_agg)
print(res3)
#           Value
# Category
# A            20
# B             5

五、透视表

pivot_table() 是 Pandas 中用于创建数据透视表的方法。数据透视表是一种用于总结和聚合数据的强大工具，可以根据一个或多个列对数据进行重新排列，以便更容易进行分析。

参数：

  • data（必需）：要创建数据透视表的 DataFrame。
  • values（必需）：要聚合的列名或列名的列表。这是要计算统计量的列。
  • index（可选）：一个或多个列名，用于作为数据透视表的行索引（行标签）。
  • columns（可选）：一个或多个列名，用于作为数据透视表的列索引（列标签）。
  • aggfunc（可选）：要应用于 values 中列的聚合函数，可以是内置聚合函数（例如 ‘sum’、‘mean’、‘count’ 等）或自定义函数。默认情况下，使用 ‘mean’。
  • fill_value（可选）：替代结果表中的缺失值。
  • margins（可选）：添加边际汇总，生成汇总统计信息。
  • dropna（可选）：默认情况下，如果所有条目都是 NaN，则删除相应的行。设置为 False 可以保留包含 NaN 值的行。
import pandas as pd  # 导入 Pandas 库并使用别名 pd

# 创建一个示例 DataFrame
data = {'Date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03'],'Category': ['A', 'B', 'A', 'B', 'A'],'Value': [10, 20, 15, 25, 30]}
df = pd.DataFrame(data)
print(df)
#          Date Category  Value
# 0  2023-01-01        A     10
# 1  2023-01-01        B     20
# 2  2023-01-02        A     15
# 3  2023-01-02        B     25
# 4  2023-01-03        A     30

# 创建数据透视表，聚合'Value'列，行索引为'Date'，列索引为'Category'，默认聚合函数为均值
pivot = pd.pivot_table(df, values='Value', index='Date', columns='Category')
print(pivot)
# Category       A     B
# Date
# 2023-01-01  10.0  20.0
# 2023-01-02  15.0  25.0
# 2023-01-03  30.0   NaN

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~

永远十八的小仙女~
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
pandas聚合函数
weixin_52730784的博客
06-20 509
聚合函数01 | 数据集02 | value_counts( )03 | groupby( ) + count ( )03 | groupby( ) + agg( )04 | groupby( ) + apply 01 | 数据集 1.来源 kaggle： https://www.kaggle.com/harlfoxem/housesalesprediction 2.简介 这是一份kaggle房屋的数据集,包含21个columns import pandas as pd df = pd.read_cs
Pandas groupby 自定义聚合函数
chaoqichaoluoe的博客
02-08 2251
# 自定义聚合函数， # n.i.o 出现次数0 -> 0 # n.i.o 出现次数1 -> 进一步判断 # n.i.o 出现次数大于2 -> 2 # 此函数需进一步扩展,出现次数大于2的，需要根据计划频率，判断是否在一次连续测试内 def peak_peak(arr,df): # 判断arr的series值中是否包含'n.i.o' x = list(arr).count('n.i.O.') # 只包含一个，条件放行 if x == 1: r
pandas数据分组与聚合
m0_64087341的博客
04-26 4994
数据分组与聚合、数据透视表与交叉表
pandas数据分析 - 分组聚合、分组转换、分组筛选
最新发布
weixin_47552266的博客
04-25 1782
在使用 pandas 进行数据处理时，分组聚合、分组转换和分组过滤是三个非常重要的概念，它们提供了强大的工具来分析和处理分组数据。
pandas访问分组里面的数据_python数据分析实战：pandas分组聚合-自定义聚合函数...
weixin_39811478的博客
11-27 190
导读：本文主要介绍利用自定义函数实现pandas数据聚合，约550字，正常阅读需要3~5分钟。之前的例子(传送门：python数据分析实战：pandas之分组聚合；python数据分析实战：pandas之层级聚合)我们已经简单介绍了数据聚合的求和操作，此外常见的聚合还包括count,min,max,mean等。很多时候这些程序内部已经实现优化的操作并不能满足我们的实际需求，我们可以自行定制聚合函数...
pyspark pandas 自定义聚合函数
人生百态361
12-14 3793
pyspark自定义聚合函数 import pyspark.sql.functions as F from pyspark.sql import SparkSession from pyspark.sql.types import IntegerType list_data={ 'label_id':['001','001','002','001','001','002','004','001','001'] ,'action_num':[3,4,5,1,2,34,5,9,2] } df1 = pd.
Python Pandas聚合函数
ccc369639963的博客
04-19 2041
Python Pandas聚合函数 在前一节，我们重点介绍了窗口函数。我们知道，窗口函数可以与聚合函数一起使用，聚合函数指的是对一组数据求总和、最大值、最小值以及平均值的操作，本节重点讲解聚合函数的应用。 应用聚合函数 首先让我们创建一个 DataFrame 对象，然后对聚合函数进行应用。 import pandas as pd import numpy as np df = pd.DataFrame(np.random.randn(5, 4),index = pd.date_range('12/14/20
Python Pandas分组聚合的实现方法
09-19
在Python的Pandas库中，分组聚合是一个强大的数据分析工具，允许我们对数据集进行复杂的统计分析。本文将深入探讨如何使用Pandas实现分组聚合，主要包括`apply()`、`applymap()`、`map()`以及`groupby()`等方法。 ...
数据分析-pandas入门-数据聚合与分组
09-08
系列文章“Python数据分析之Pandas入门（中）”的第七小节，主要介绍了在载入、合并和准备数据集后，可能还需要对源数据集进行过滤、变换和分割等操作。，本节内容与 中的“六、数据规整”一同作为将用于报告的数据...
pandas数据分组和聚合操作方法
09-20
本文主要探讨了Pandas中的数据分组和聚合操作，这是数据分析过程中非常关键的步骤，能够帮助我们有效地摘要和理解数据。 Pandas的GroupBy机制遵循"split-apply-combine"的模式，即将数据拆分（split）、对每个子集...
Pandas数据分析代码
04-25
总的来说，“Pandas数据分析代码”这一资源将帮助你掌握使用Pandas进行数据分析的基本技能，包括但不限于数据清洗、转换、整合、分组和可视化。通过实践这些代码示例，你可以更深入地理解Pandas的强大功能，并提升...
数据分析-pandas入门-案例分析
09-08
在数据分析领域，Pandas是一个非常重要的工具，尤其对于初学者来说，它是理解并处理数据集的首选库。本文将深入探讨在"数据分析-pandas入门-案例分析"中的关键知识点，帮助你更好地掌握Pandas的使用。 首先，让我们...
Python 数据分析&pandas基础.rar
03-24
Python数据分析与pandas库是现代数据科学领域中最常用和强大的工具之一。Pandas是一个开源的Python库，专门设计用于处理和分析结构化数据。它构建在NumPy之上，提供了高效的数据结构，如DataFrame和Series，使得数据...
pandas超市数据分析.rar
07-09
在数据分析阶段，我们可能利用pandas进行数据分组（`groupby()`）和聚合（`agg()`），比如计算每个商品类别的销售额总和。我们还会运用条件筛选（`loc[]`和`query()`）来查找特定条件下的记录，以及排序（`sort_...
Python数据分析模块pandas用法详解
09-18
以上只是pandas库的冰山一角，实际使用中，pandas还提供了更高级的功能，如分组聚合（`groupby`）、时间窗口操作（rolling, expanding, ewm）、数据排序（`sort_values`）等。通过学习和熟练掌握pandas，可以极大地...
Pandas数据分析笔记
01-23
**Pandas数据分析笔记** Pandas是Python编程语言中一个强大的数据处理库，它为数据分析提供了高效、灵活且易于使用的工具。本笔记旨在帮助初学者快速掌握Pandas的基础知识和核心功能，通过12个部分逐步深入，使你...
Python Pandas窗口函数
ccc369639963的博客
04-19 3865
Python Pandas窗口函数 为了能更好地处理数值型数据，Pandas 提供了几种窗口函数，比如移动函数（rolling）、扩展函数（expanding）和指数加权函数（ewm）。 窗口函数应用场景非常多。举一个简单的例子：现在有 10 天的销售额，而您想每 3 天求一次销售总和，也就说第五天的销售额等于（第三天 + 第四天 + 第五天）的销售额之和，此时窗口函数就派上用场了。 窗口是一种形象化的叫法，这些函数在执行操作时，就如同窗口一样在数据区间上移动。 本节学习主要讲解如何在 DataFrame
pandas第四章-分组、聚合函数
Sun123234的博客
08-02 503
pandas第四章-分组、聚合函数
【Pandas分组聚合】进阶：使用自定义函数方法 transform() 、apply()
weixin_45760274的博客
03-15 3105
【Pandas】使用自定义方法 dataframe() apply()
pandas分组聚合详解
06-03
Pandas是Python中一个非常常用的数据分析库，其中的groupby()函数可以对数据进行分组聚合操作，该函数支持多种聚合函数，包括sum()、mean()、count()、max()、min()等，也支持自定义聚合函数。 以下是一个更加详细的Pandas分组聚合操作的例子： ``` import pandas as pd import numpy as np # 创建一个DataFrame数据 df = pd.DataFrame({ 'key1': ['a', 'a', 'b', 'b', 'a', 'b', 'a', 'b'], 'key2': ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two'], 'data1': np.random.randn(8), 'data2': np.random.randn(8) }) # 对数据按照'key1'列进行分组，并对每组数据的'data1'列进行求和操作 grouped = df.groupby('key1') result = grouped['data1'].sum() # 输出结果 print(result) ``` 输出结果为： ``` key1 a 0.976359 b -0.902755 Name: data1, dtype: float64 ``` 表示对数据按照'key1'列进行分组，并对每组数据的'data1'列进行求和操作。 以下是一个更加复杂的分组聚合操作的例子： ``` import pandas as pd import numpy as np # 创建一个DataFrame数据 df = pd.DataFrame({ 'key1': ['a', 'a', 'b', 'b', 'a', 'b', 'a', 'b'], 'key2': ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two'], 'data1': np.random.randn(8), 'data2': np.random.randn(8) }) # 对数据按照'key1'列和'key2'列进行分组，并对每组数据的'data1'列进行求和和求均值操作 grouped = df.groupby(['key1', 'key2']) result = grouped.agg({'data1': ['sum', 'mean']}) # 输出结果 print(result) ``` 输出结果为： ``` data1 sum mean key1 key2 a one -0.139849 -0.069925 two 1.557208 0.778604 b one -0.537986 -0.537986 two -0.364769 -0.182384 ``` 表示对数据按照'key1'列和'key2'列进行分组，并对每组数据的'data1'列进行求和和求均值操作。 除了使用Pandas内置的聚合函数外，也可以自定义聚合函数。以下是一个自定义聚合函数的例子： ``` import pandas as pd import numpy as np # 创建一个DataFrame数据 df = pd.DataFrame({ 'key1': ['a', 'a', 'b', 'b', 'a', 'b', 'a', 'b'], 'key2': ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two'], 'data1': np.random.randn(8), 'data2': np.random.randn(8) }) # 自定义聚合函数 def peak_to_peak(arr): return arr.max() - arr.min() # 对数据按照'key1'列进行分组，并对每组数据的'data1'列进行自定义聚合函数操作 grouped = df.groupby('key1') result = grouped['data1'].agg(peak_to_peak) # 输出结果 print(result) ``` 输出结果为： ``` key1 a 1.426003 b 0.664204 Name: data1, dtype: float64 ``` 表示对数据按照'key1'列进行分组，并对每组数据的'data1'列进行自定义聚合函数操作，该自定义函数计算每组数据的最大值和最小值之差。 希望这些例子可以帮助您更好地了解Pandas的分组聚合操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值