智能风控数据分析 groupby、apply、reset

groupby——分组

本例

apply——对每个分组应用一个函数

等价用法

reset_index——重置索引

使用前编辑

注意事项

groupby必须配合聚合函数、

关于agglist

一些groupby试验

1. groupby对象之后。sum（一个列名）

2. groupby对象之后。sum（2个列名）

3. groupby对象之后。sum（空）编辑

sum添加一个列明

一样，只有数字上榜编辑

sum添加俩列名编辑

书上官方：apply后自己定义列名

是否有列表框住很重要

其他用法

np。nansum

例axis=0 未指定列名，把他们放到了一个列表编辑

axis=0，指定列名，只有这个咧

编辑axis=1报错1啊编辑

df_g = df.groupby('uid')  # 按照uid进行分组
gn = pd.DataFrame()  # 创建一个空的DataFrame用于存储结果
for i in agg_list:  # 遍历agg_list列表
    if isinstance(i, str):  # 如果i是字符串类型
        tp = pd.DataFrame(df_g.groupby('uid').apply(lambda df: len(df[i])).reset_index())  # 对每个组应用lambda函数计算长度，并将索引重置
        tp.columns = ['uid', i + '_cnt']  # 设置列名
        if gn.empty == True:  # 如果gn为空
            gn = tp  # 将tp赋值给gn
        else:
            gn = pd.merge(gn, tp, on='uid', how='left')  # 合并gn和tp
    elif isinstance(i, int):  # 如果i是整数类型
        tp = pd.DataFrame(df_g.groupby('uid').apply(lambda df: np.where(df[i] > 0, 1, 0).sum()).reset_index())  # 对每个组应用lambda函数计算满足条件的元素的和，并将索引重置
        tp.columns = ['uid', i + '_num']
        if gn.empty == True:
            gn = tp
        else:
            gn = pd.merge(gn, tp, on='uid', how='left')
    elif isinstance(i, float):  # 如果i是浮点数类型
        tp = pd.DataFrame(df_g.groupby('uid').apply(lambda df: np.nansum(df[i])).reset_index())  # 对每个组应用lambda函数计算非NaN值的和，并将索引重置
        tp.columns = ['uid', i + '_tot']
        if gn.empty == True:
            gn = tp
        else:
            gn = pd.merge(gn, tp, on='uid', how='left')
    elif isinstance(i, list):  # 如果i是列表类型
        tp = pd.DataFrame(df_g.groupby('uid').apply(lambda df: np.nanmean(df[i])).reset_index())  # 对每个组应用lambda函数计算平均值，并将索引重置
        tp.columns = ['uid', i + '_avg']
        if gn.empty == True:
            gn = tp
        else:
            gn = pd.merge(gn, tp, on='uid', how='left')
    else:  # 其他情况
        tp = pd.DataFrame(df_g.groupby('uid').apply(lambda df: np.nanmax(df[i])).reset_index())  # 对每个组应用lambda函数计算最大值，并将索引重置
        tp.columns = ['uid', i + '_max']
        if gn.empty == True:
            gn = tp
        else:
            gn = pd.merge(gn, tp, on='uid', how='left')

groupby——分组

groupby 是 pandas 库中一个非常重要的功能，它用于将数据分组并对每个组应用函数。groupby 的基本用法是将 DataFrame 分成多个组，每个组由一个或多个唯一值定义。

语法：

DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

关键参数：

by: 用于分组的键，可以是列名、列名的列表或一个返回分组键的函数。
axis: 指定分组是在哪个轴上进行的，默认为 0（行）。
as_index: 默认为 True，表示返回的 DataFrame 中的分组键作为索引。如果设置为 False，则分组键将作为列返回。

本例

df.groupby('uid')

这会按照 ‘uid’ 列的值对 DataFrame 进行分组。

apply——对每个分组应用一个函数

apply 函数用于对 DataFrame 中的每个组应用一个函数。这个函数可以是自定义的，也可以是 pandas 中的内置函数。

语法：

DataFrameGroupBy.apply(func, *args, **kwargs)

关键参数：

func: 应用于每个组的函数。

例子：

df_g.apply(lambda df: np.sum(df['value']))

这会对每个组应用一个 lambda 函数，计算 ‘value’ 列的总和。

返回这个函数的结果dataframe

等价用法

其中，.df_g.apply(lambda df: np.sum(df['value']))等价于groupby对象.sum(列名即“value”)

例pd.DataFrame(customers_df.groupby(["Time"]).sum('CustomerID'))

reset_index——重置索引

reset_index 用于重置 DataFrame 的索引，或者将索引的级别转换为列。这在 groupby 操作后特别有用，因为 groupby 默认会将分组键作为索引。

语法：

DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')

关键参数：

level: 如果是多级索引，可以指定要重置的级别。
drop: 如果为 True，则重置索引后，原始索引将不会作为列添加到 DataFrame 中。
inplace: 如果为 True，则直接在原始 DataFrame 上修改，不返回新的 DataFrame。

例子：

df_g.reset_index()

这会将分组后的 DataFrame 的索引重置，并将原来的索引作为 DataFrame 的一列。

返回重置后的dataframe

使用前

使用后

结合以上三个功能，代码中的例子可以这样解释：

df_g = df.groupby('uid')  # 按照列 'uid' 对 DataFrame 进行分组
gn = pd.DataFrame()  # 创建一个空的 DataFrame 用于存储结果
for i in agg_list:  # 遍历一个聚合操作的列表
    # ... 对每个分组应用不同的聚合函数 ...
    tp = pd.DataFrame(df_g[i].apply(lambda df: np.sum(df)).reset_index())  # 应用聚合函数并重置索引
    # ... 合并结果到 gn DataFrame ...

在这个例子中，groupby 用于创建分组，apply 用于对每个分组执行聚合操作，而 reset_index 用于将聚合后的结果转换为 DataFrame，并保留原始的分组键作为一列。

注意事项

groupby必须配合聚合函数、

聚合函数可以是groupby对象后面。后缀

、也可以是。apply自定义

当你使用 pd.DataFrame(customers_df.groupby(['Time', "CustomerID"])) 时，你实际上是将 groupby 对象转换成了一个 DataFrame。groupby 对象本身是一个中间对象，用于表示分组操作，它包含了原始 DataFrame 的分组信息，但并不包含聚合后的结果。

import pandas as pd

# 客户信息 DataFrame
customers_df = pd.DataFrame({
    'CustomerID': [1, 2, 3, 4],
    'CustomerName': ['Alice', 'Bob', 'Charlie', 'David'],
    'Time': [10, 20, 10, 40]
})

# 将 groupby 对象转换为 DataFrame
grouped_df = pd.DataFrame(customers_df.groupby(['Time', "CustomerID"]))

print(grouped_df)

输出将是一个包含两个列的 DataFrame，这两个列是 'Time' 和 'CustomerID'，它们表示分组键。这个 DataFrame 的每一行代表一个唯一的分组。但是，由于没有应用任何聚合函数，这个 DataFrame 不会包含任何关于分组内容的聚合信息。

输出看起来像这样：

       Time  CustomerID
0 10      1          1
1 20      2          2
2 10      3          3
3 40      4          4

解释：

groupby(['Time', "CustomerID"]) 创建了一个分组对象，这个对象根据 ‘Time’ 和 ‘CustomerID’ 的每个唯一组合对数据进行分组。
由于没有指定聚合函数，转换成 DataFrame 后，它只是显示了分组键的组合，并没有显示每个组中的数据。
在这个特定的例子中，由于 ‘CustomerID’ 是唯一的，所以每个 ‘Time’ 和 ‘CustomerID’ 的组合都是唯一的，因此这个操作并没有实际上的分组效果，它只是简单地展示了每一行数据的 ‘Time’ 和 ‘CustomerID’。

如果你想要查看每个组中的数据，你应该在 groupby 后面应用聚合函数，例如 .size()、.sum()、.mean() 等，然后可能需要使用 .reset_index() 来将结果转换成一个 DataFrame。例如：

grouped_df = customers_df.groupby(['Time', "CustomerID"]).size().reset_index(name='Count')
print(grouped_df)

这将输出每个分组中的元素数量。

关于agglist

在Python中，当你在循环中使用for i in agg_list:时，agg_list通常是包含要处理的项或值的列表。在这个上下文中，agg_list可能包含一些聚合函数的名字或者是其他与数据处理相关的参数。具体来说，这取决于你正在进行的任务和你如何定义和使用agg_list。

例如，如果你的程序涉及到数据分析，并且你想对不同列的数据进行某种形式的聚合（如求和、平均值等），那么agg_list可能会包含字符串形式的函数名称，如['sum', 'mean']，然后在循环内部对这些函数进行处理。

再举一个具体的例子，假设你有如下代码片段：

python

复制

agg_list = ['sum', 'mean']
dataframe = pd.DataFrame(...)  # 假设这是一个已经存在的DataFrame

for func_name in agg_list:
    if func_name == 'sum':
        result = dataframe.sum()
    elif func_name == 'mean':
        result = dataframe.mean()
    # ... 其他可能的聚合函数处理 ...
    
    print(f"The {func_name} of the data is: {result}")

在这个例子中，agg_list就是一个包含字符串的列表，其中每个字符串代表一种聚合函数的名称。通过遍历这个列表，我们可以依次调用相应的聚合函数来处理数据。

总结一下，agg_list通常是一个列表，其中包含你要执行的某些操作的相关信息，如函数名称、参数等。具体的内容取决于你的编程需求和上下文。

书上:agg_list='oil_amount','discount_amount','sale_amount','amount',,'pay_amount','coupon_amount'等等。并不是前面所说的sum average之流

一些groupby试验

1. groupby对象之后。sum（一个列名）

仅显示为数字的列，name这列没写，并且另一列也作用了这个sum函数，即使没有写这一列的名字

2. groupby对象之后。sum（2个列名）

比1多了name一列，三列统统使用了sum操作，name是字符串的相加

3. groupby对象之后。sum（空）

与1相同的结果，name又没了

sum添加一个列明

一样，只有数字上榜

sum添加俩列名

2or3结果一样，name上榜

这个用法似乎不太正规

书上官方：apply后自己定义列名

这个结合apply及lambda自定义函数的方法会丢失列名且仅有此列

是否有列表框住很重要

无

name赫然在列

有

name消失。且保留有其他数字的列

哪怕是只有一个列名的列表

其他用法

np。nansum

只能给他一列，多了会报错。

np.nanmin 是 NumPy 库中的一个函数，

——忽略nan的某函数们，具体有nanmin nanmax nanvar nansum nanmean

他们通常作用在一维nparray上

如果用到多维，需要指定axis

例axis=0 未指定列名，把他们放到了一个列表

axis=0，指定列名，只有这个咧

axis=1报错1啊

用于计算数组中非 NaN (Not a Number) 值的最小值。当数组中包含 NaN 值时，标准的 min 函数会返回 NaN，而 np.nanmin 会忽略这些 NaN 值并返回剩余非 NaN 值中的最小值。

以下是 np.nanmin 的基本用法：

import numpy as np

# 创建一个包含 NaN 值的数组
arr = np.array([1, 2, np.nan, 4, np.nan, 6])

# 使用 np.nanmin 计算非 NaN 值的最小值
min_value = np.nanmin(arr)

print(min_value)  # 输出: 1

以下是 np.nanmin 的一些其他特性：

它可以接受一个 axis 参数，用于计算指定轴上的最小值。
它可以接受一个 out 参数，用于指定输出数组。

例子：

# 创建一个二维数组
arr_2d = np.array([[1, 2, np.nan], [np.nan, 4, 6], [7, np.nan, 9]])

# 计算每一列的非 NaN 最小值
min_values_per_column = np.nanmin(arr_2d, axis=0)

print(min_values_per_column)  # 输出: [1 2 6]

# 计算每一行的非 NaN 最小值
min_values_per_row = np.nanmin(arr_2d, axis=1)

print(min_values_per_row)  # 输出: [1 4 7]

在这个例子中，axis=0 表示沿着列的方向计算最小值，而 axis=1 表示沿着行的方向计算最小值。np.nanmin 会自动忽略每列或每行中的 NaN 值。