第四章 分组

import numpy as np
import pandas as pd

一、分组模式及其对象

1. 分组的一般模式

分组操作在日常生活中使用极其广泛，例如：

• 依据$性别$分组，统计全国人口$寿命$的$平均值$
• 依据$季节$分组，对每一个季节的$温度$进行$组内标准化$
• 依据$班级$筛选出组内$数学分数$的$平均值超过80分的班级$

从上述的几个例子中不难看出，想要实现分组操作，必须明确三个要素：$分组依据$、$数据来源$、$操作及其返回结果$。同时从充分性的角度来说，如果明确了这三方面，就能确定一个分组操作，从而分组代码的一般模式即：

df.groupby(分组依据)[数据来源].使用操作

例如第一个例子中的代码就应该如下：

df.groupby('Gender')['Longevity'].mean()

现在返回到学生体测的数据集上，如果想要按照性别统计身高中位数，就可以如下写出：

df = pd.read_csv('../data/learn_pandas.csv')
df.groupby('Gender')['Height'].median()

2. 分组依据的本质

前面提到的若干例子都是以单一维度进行分组的，比如根据性别，如果现在需要根据多个维度进行分组，该如何做？事实上，只需在groupby中传入相应列名构成的列表即可。例如，现希望根据学校和性别进行分组，统计身高的均值就可以如下写出：

df.groupby(['School', 'Gender'])['Height'].mean()

目前为止，groupby的分组依据都是直接可以从列中按照名字获取的，那如果希望通过一定的复杂逻辑来分组，例如根据学生体重是否超过总体均值来分组，同样还是计算身高的均值。

首先应该先写出分组条件：

condition = df.Weight > df.Weight.mean()

然后将其传入groupby中：

df.groupby(condition)['Height'].mean()

【练一练】
请根据上下四分位数分割，将体重分为high、normal、low三组，统计身高的均值。

df['core'] = pd.cut(df['Weight'],[0,df.Weight.quantile(0.25),df.Weight.quantile(0.75),df.Weight.max()],labels=['low','normal','high'])
df.head()

df.groupby(['core'])['Height'].mean()

从索引可以看出，其实最后产生的结果就是按照条件列表中元素的值（此处是True和False）来分组，下面用随机传入字母序列来验证这一想法：

item = np.random.choice(list('abc'), df.shape[0])
df.groupby(item)['Height'].mean()

此处的索引就是原先item中的元素，如果传入多个序列进入groupby，那么最后分组的依据就是这两个序列对应行的唯一组合：

df.groupby([condition, item])['Height'].mean()

由此可以看出，之前传入列名只是一种简便的记号，事实上等价于传入的是一个或多个列，最后分组的依据来自于数据来源组合的unique值，通过drop_duplicates就能知道具体的组类别：

df[['School', 'Gender']].drop_duplicates()

df.groupby([df['School'], df['Gender']])['Height'].mean()

3. Groupby对象

能够注意到，最终具体做分组操作时，所调用的方法都来自于pandas中的groupby对象，这个对象上定义了许多方法，也具有一些方便使用的属性。

gb = df.groupby(['School', 'Grade'])
gb

通过ngroups属性，可以得到分组个数：

gb.ngroups

通过groups属性，可以返回从$组名$映射到$组索引列表$的字典：

res = gb.groups
res.keys() # 字典的值由于是索引，元素个数过多，此处只展示字典的键

当size作为DataFrame的属性时，返回的是表长乘以表宽的大小，但在groupby对象上表示统计每个组的元素个数：

gb.size()

通过get_group方法可以直接获取所在组对应的行，此时必须知道组的具体名字：

gb.get_group(('Fudan University', 'Freshman'))

4. 分组的三大操作

熟悉了一些分组的基本知识后，重新回到开头举的三个例子，可能会发现一些端倪，即这三种类型分组返回的数据型态并不一样：

• 第一个例子中，每一个组返回一个标量值，可以是平均值、中位数、组容量size等
• 第二个例子中，做了原序列的标准化处理，也就是说每组返回的是一个Series类型
• 第三个例子中，既不是标量也不是序列，返回的整个组所在行的本身，即返回了DataFrame类型

由此，引申出分组的三大操作：聚合、变换和过滤，分别对应了三个例子的操作，下面就要分别介绍相应的agg、transform和filter函数及其操作。

二、聚合函数

1. 内置聚合函数

在介绍agg之前，首先要了解一些直接定义在groupby对象的聚合函数，因为它的速度基本都会经过内部的优化，使用功能时应当优先考虑。根据返回标量值的原则，包括如下函数：max/min/mean/median/count/all/any/idxmax/idxmin/mad/nunique/skew/quantile/sum/std/var/sem/size/prod。

gb = df.groupby('Gender')['Height']
gb.idxmin()

gb.quantile(0.95)

【练一练】
请查阅文档，明确all/any/mad/skew/sem/prod函数的含义。
【all】判断给定参数中元素是否为True,除0，NaN，None，False外都算True。
【any】判断给定参数中元素是否全为False，则返回False，如果有一个True，则返回True。
【mad】求平均绝对误差（数据与平均值之间的平均距离）
【skew】求偏度（三阶标准化矩）
【sem】求平均值的无偏标准误差（SEM平均值标准误差）
【prod】计算所有元素乘积

这些聚合函数当传入的数据来源包含多个列时，将按照列进行迭代计算：

gb = df.groupby('Gender')[['Height', 'Weight']]
gb.max()

2. agg方法

虽然在groupby对象上定义了许多方便的函数，但仍然有以下不便之处：

• 无法同时使用多个函数
• 无法对特定的列使用特定的聚合函数
• 无法使用自定义的聚合函数
• 无法直接对结果的列名在聚合前进行自定义命名

下面说明如何通过agg函数解决这四类问题：

【a】使用多个函数

当使用多个聚合函数时，需要用列表的形式把内置聚合函数对应的字符串传入，先前提到的所有字符串都是合法的。

gb.agg(['sum', 'idxmax', 'skew'])

从结果看，此时的列索引为多级索引，第一层为数据源，第二层为使用的聚合方法，分别逐一对列使用聚合，因此结果为6列。

【b】对特定的列使用特定的聚合函数

对于方法和列的特殊对应，可以通过构造字典传入agg中实现，其中字典以列名为键，以聚合字符串或字符串列表为值。

gb.agg({'Height':['mean','max'], 'Weight':'count'})

【练一练】
请使用【b】中的传入字典的方法完成【a】中等价的聚合任务

gb.agg({'Height':['sum','idxmax','skew'],
        'Weight':['sum','idxmax','skew']})

【c】使用自定义函数

在agg中可以使用具体的自定义函数，$需要注意传入函数的参数是之前数据源中的列，逐列进行计算$。下面分组计算身高和体重的极差：

gb.agg(lambda x: x.mean()-x.min())

由于传入的是序列，因此序列上的方法和属性都是可以在函数中使用的，只需保证返回值是标量即可。下面的例子是指，如果组的指标均值，超过该指标的总体均值，返回High，否则返回Low。

def my_func(s):
    res = 'High'
    if s.mean() <= df[s.name].mean():
        res = 'Low'
    return res
gb.agg(my_func)

【d】聚合结果重命名

如果想要对聚合结果的列名进行重命名，只需要将上述函数的位置改写成元组，元组的第一个元素为新的名字，第二个位置为原来的函数，包括聚合字符串和自定义函数，现举若干例子说明：

gb.agg([('range', lambda x: x.max()-x.min()), ('my_sum', 'sum')])

gb.agg({'Height': [('my_func', my_func), 'sum'], 'Weight': lambda x:x.max()})

另外需要注意，使用对一个或者多个列使用单个聚合的时候，重命名需要加方括号，否则就不知道是新的名字还是手误输错的内置函数字符串：

gb.agg([('my_sum', 'sum')])

gb.agg({'Height': [('my_func', my_func), 'sum'], 'Weight': [('range', lambda x:x.max())]})

三、变换和过滤

1. 变换函数与transform方法

变换函数的返回值为同长度的序列，最常用的内置变换函数是累计函数：cumcount/cumsum/cumprod/cummax/cummin，它们的使用方式和聚合函数类似，只不过完成的是组内累计操作。

gb.cummax().head()

【练一练】
在groupby对象中，rank方法也是一个实用的变换函数，请查阅它的功能并给出一个使用的例子。
Provide the rank of values within each group，大体意思是分别在分组后的每一个列中对值进行排序，输出的是样本的排序值。例如：

gb.rank()

当用自定义变换时需要使用transform方法，被调用的自定义函数，$其传入值为数据源的序列$，与agg的传入类型是一致的，其最后的返回结果是行列索引与数据源一致的DataFrame。

现对身高和体重进行分组标准化，即减去组均值后除以组的标准差：

gb.transform(lambda x: (x-x.mean())/x.std()).head()

【练一练】
对于transform方法无法像agg一样，通过传入字典来对指定列使用特定的变换，如果需要在一次transform的调用中实现这种功能，请给出解决方案。

将列名和对应方法使用字典变量传递，然后自定义一个函数，识别除传入参数的列名，进而根据字典变量得到这一列对应的方法。

def my_func(x,dic):
    func=dic[x.name]#x.name返回的是x所在这一列的列名。
    if(func=='max'):
        return x.max()
    elif(func=='min'):
        return x.min()
    elif(func=='mean'):
        return x.mean()
    else:
         return None
         
gb.transform(my_func,{'Height':'mean','Weight':'max'})

前面提到了transform只能返回同长度的序列，但事实上还可以返回一个标量，这会使得结果被广播到其所在的整个组，这种$标量广播$的技巧在特征工程中是非常常见的。例如，构造两列新特征来分别表示样本所在性别组的身高均值和体重均值：

gb.transform('mean').head() # 传入返回标量的函数也是可以的

2. 组索引与过滤

在上一章中介绍了索引的用法，那么索引和过滤有什么区别呢？

过滤在分组中是对于组的过滤，而索引是对于行的过滤，在第二章中的返回值，无论是布尔列表还是元素列表或者位置列表，本质上都是对于行的筛选，即如果符合筛选条件的则选入结果表，否则不选入。

组过滤作为行过滤的推广，指的是如果对一个组的全体所在行进行统计的结果返回True则会被保留，False则该组会被过滤，最后把所有未被过滤的组其对应的所在行拼接起来作为DataFrame返回。

在groupby对象中，定义了filter方法进行组的筛选，其中自定义函数的输入参数为数据源构成的DataFrame本身，在之前例子中定义的groupby对象中，传入的就是df[['Height', 'Weight']]，因此所有表方法和属性都可以在自定义函数中相应地使用，同时只需保证自定义函数的返回为布尔值即可。

例如，在原表中通过过滤得到所有容量大于100的组：

gb.filter(lambda x: x.shape[0] > 100).head()

【练一练】
从概念上说，索引功能是组过滤功能的子集，请使用filter函数完成loc[...]的功能，这里假设"..."是元素列表。

使用‘learn_pandas.csv’数据，其Index为默认的正整数。loc[.]可以直接对Index进行索引，使用分组的话，想法是先按index进行分组，这样每个样本为一组，然后使用filter函数再过滤，过滤条件为Index。

df.loc[[1,2,3]]
df.groupby([i for i in range(df.shape[0])]).filter(lambda x:x.index.isin([1,2,3])[0])#这个[0]必须要加，否则返回的不是标量布尔值。

四、跨列分组

1. apply的引入

之前几节介绍了三大分组操作，但事实上还有一种常见的分组场景，无法用前面介绍的任何一种方法处理，例如现在如下定义身体质量指数BMI：
$$\mathrm{BMI}=\frac{\mathrm{Weight}}{\mathrm{Heigh}{\mathrm{t}}^2}$$
其中体重和身高的单位分别为千克和米，需要分组计算组BMI的均值。

首先，这显然不是过滤操作，因此filter不符合要求；其次，返回的均值是标量而不是序列，因此transform不符合要求；最后，似乎使用agg函数能够处理，但是之前强调过聚合函数是逐列处理的，而不能够$多列数据同时处理$。由此，引出了apply函数来解决这一问题。

2. apply的使用

在设计上，apply的自定义函数传入参数与filter完全一致，只不过后者只允许返回布尔值。现如下解决上述计算问题：

def BMI(x):
    Height = x['Height']/100
    Weight = x['Weight']
    BMI_value = Weight/Height**2
    return BMI_value.mean()
gb.apply(BMI)

除了返回标量之外，apply方法还可以返回一维Series和二维DataFrame，但它们产生的数据框维数和多级索引的层数应当如何变化？下面举三组例子就非常容易明白结果是如何生成的：
【a】标量情况：结果得到的是 Series ，索引与 agg 的结果一致

gb = df.groupby(['Gender','Test_Number'])[['Height','Weight']]
gb.apply(lambda x: 0)

gb.apply(lambda x: [0, 0]) # 虽然是列表，但是作为返回值仍然看作标量

【b】Series情况：得到的是DataFrame，行索引与标量情况一致，列索引为Series的索引

gb.apply(lambda x: pd.Series([0,0],index=['a','b']))

【练一练】
请尝试在apply传入的自定义函数中，根据组的某些特征返回相同长度但索引不同的Series，会报错吗？

gb = df.groupby(['Gender','Test_Number'])[['Height','Weight']]
gb.apply(lambda x:pd.Series([0,1],index=['a','b']) if (x.shape[0]>50) else pd.Series([0,1],index=['c','d']))

【c】DataFrame情况：得到的是DataFrame，行索引最内层在每个组原先agg的结果索引上，再加一层返回的DataFrame行索引，同时分组结果DataFrame的列索引和返回的DataFrame列索引一致。

gb.apply(lambda x: pd.DataFrame(np.ones((2,2)), index = ['a','b'], columns=pd.Index([('w','x'),('y','z')])))

【练一练】
请尝试在apply传入的自定义函数中，根据组的某些特征返回相同大小但列索引不同的DataFrame，会报错吗？如果只是行索引不同，会报错吗？

gd.apply(lambda x:pd.DataFrame([[1,2],[3,4]],index=['a','b'],columns=['c','d']) if (x.shape[0]>50) else pd.DataFrame([[1,2],[3,4]],index=['aa','bb'],columns=['c','d']))

最后需要强调的是，apply函数的灵活性是以牺牲一定性能为代价换得的，除非需要使用跨列处理的分组处理，否则应当使用其他专门设计的groupby对象方法，否则在性能上会存在较大的差距。同时，在使用聚合函数和变换函数时，也应当优先使用内置函数，它们经过了高度的性能优化，一般而言在速度上都会快于用自定义函数来实现。
【练一练】
在groupby对象中还定义了cov和corr函数，从概念上说也属于跨列的分组处理。请利用之前定义的gb对象，使用apply函数实现与gb.cov()同样的功能并比较它们的性能。

gb = df.groupby(['Gender','Test_Number'])[['Height','Weight']]
def my_cov(x,y):
    x_var=np.nanvar(x) #计算自身的方差
    y_var=np.nanvar(y) #计算自身的方差
    x=x[x.notnull().values].reset_index(drop=True)#去除NaN值，并初始化索引。
    y =y[y.notnull().values].reset_index(drop=True)

    #去重后x与y的长度不同，计算协方差需要两个序列长度相同，所以对长度长的裁剪。
    if(x.shape[0]<y.shape[0]):
        y=y[0:x.shape[0]]
    elif(x.shape[0]>y.shape[0]):
        x = x[0:y.shape[0]]
        
    x_y_var=(x-x.mean()).dot(y-y.mean())/(x.shape[0]-1)#计算协方差的无偏估计。
    return [[x_var,x_y_var],[x_y_var,y_var]]

gb.apply(lambda x:pd.DataFrame(my_cov(x.Height,x.Weight),index=['Height','Weight'],columns=['Height','Weight']))

gb.cov()

五、练习

Ex1：汽车数据集

现有一份汽车数据集，其中Brand, Disp., HP分别代表汽车品牌、发动机蓄量、发动机输出。

df = pd.read_csv('../data/car.csv')
df.head(3)

1. 先过滤出所属Country数超过2个的汽车，即若该汽车的Country在总体数据集中出现次数不超过2则剔除，再按Country分组计算价格均值、价格变异系数、该Country的汽车数量，其中变异系数的计算方法是标准差除以均值，并在结果中把变异系数重命名为CoV。

df = pd.read_csv('../data/car.csv')
df.groupby('Country').filter(lambda x:x.shape[0]>2).groupby('Country')['Price'].agg([('CoV', lambda x: x.std()/x.mean()), 'mean', 'count'])

2. 按照表中位置的前三分之一、中间三分之一和后三分之一分组，统计Price的均值。

df.shape[0]

condition = ['Head']*20+['Mid']*20+['Tail']*20
df.groupby(condition)['Price'].mean()

3. 对类型Type分组，对Price和HP分别计算最大值和最小值，结果会产生多级索引，请用下划线把多级列索引合并为单层索引。

res = df.groupby('Type').agg({'Price': ['max'], 'HP': ['min']})
res.columns = res.columns.map(lambda x:'_'.join(x))
res

4. 对类型Type分组，对HP进行组内的min-max归一化。

def normalize(s):
    s_min, s_max = s.min(), s.max()
    res = (s - s_min)/(s_max - s_min)
    return res
df.groupby('Type')['HP'].transform(normalize).head()

5. 对类型Type分组，计算Disp.与HP的相关系数。

df.groupby('Type')[['HP', 'Disp.']].apply(lambda x:np.corrcoef(x['HP'].values, x['Disp.'].values)[0,1])

Ex2：实现transform函数

• groupby对象的构造方法是my_groupby(df, group_cols)
• 支持单列分组与多列分组
• 支持带有标量广播的my_groupby(df)[col].transform(my_func)功能
• pandas的transform不能跨列计算，请支持此功能，即仍返回Series但col参数为多列
• 无需考虑性能与异常处理，只需实现上述功能，在给出测试样例的同时与pandas中的transform对比结果是否一致

class my_groupby:
    def __init__(self, my_df, group_cols):
        self.my_df = my_df.copy()
        self.groups = my_df[group_cols].drop_duplicates()
        if isinstance(self.groups, pd.Series):
            self.groups = self.groups.to_frame()
        self.group_cols = self.groups.columns.tolist()
        self.groups = {i: self.groups[i].values.tolist() for i in self.groups.columns}
        self.transform_col = None
    def __getitem__(self, col):
        self.pr_col = [col] if isinstance(col, str) else list(col)
        return self
    def transform(self, my_func):
        self.num = len(self.groups[self.group_cols[0]])
        L_order, L_value = np.array([]), np.array([])
        for i in range(self.num):
            group_df = self.my_df.reset_index().copy()
            for col in self.group_cols:
                group_df = group_df[group_df[col]==self.groups[col][i]]
            group_df = group_df[self.pr_col]
            if group_df.shape[1] == 1:
                group_df = group_df.iloc[:, 0]
            group_res = my_func(group_df)
            if not isinstance(group_res, pd.Series):
                group_res = pd.Series(group_res,index=group_df.index,name=group_df.name)
            L_order = np.r_[L_order, group_res.index]
            L_value = np.r_[L_value, group_res.values]
        self.res = pd.Series(pd.Series(L_value, index=L_order).sort_index().values,index=self.my_df.reset_index().index, name=my_func.__name__)
        return self.res

my_groupby(df, 'Type')

单列分组：

def f(s):
    res = (s-s.min())/(s.max()-s.min())
    return res
my_groupby(df, 'Type')['Price'].transform(f).head()

df.groupby('Type')['Price'].transform(f).head()

多列分组：

my_groupby(df, ['Type','Country'])['Price'].transform(f).head()

df.groupby(['Type','Country'])['Price'].transform(f).head()

标量广播：

my_groupby(df, 'Type')['Price'].transform(lambda x:x.mean()).head()

df.groupby('Type')['Price'].transform(lambda x:x.mean()).head()

跨列计算：

my_groupby(df, 'Type')['Disp.', 'HP'].transform(lambda x: x['Disp.']/x.HP).head()

参考资料

https://blog.csdn.net/Shudddd/article/details/111657667
https://blog.csdn.net/king_without_clothes/article/details/111675362