pandas学习笔记(四)
pandas学习笔记(四) ——分组
分组模式及其对象
1.分组的一般模式
分组操作的三要素:分组依据、数据来源、操作及其返回结果。
同时从充分性的角度来说,如果明确了这三方面,就能确定一个分组操作,从而分组代码的一般模式即:
df.groupby(分组依据)[数据来源].使用操作
例:按照性别统计年龄的中位数,可以如下写出:
df.groupby('Sex')['Age'].median()
Out[10]:
Sex
female 27.0
male 29.0
Name: Age, dtype: float64
2.分组依据的本质
前面提到的若干例子都是以单一维度进行分组的,比如根据性别,如果现在需要根据多个维度进行分组,该如何做?事实上,只需在 groupby
中传入相应列名构成的列表即可。
例:根据乘客的目的港口和性别进行分组,统计年龄的均值,就可以如下写出:
df.groupby(['Embarked','Sex'])['Age'].mean()
Out[11]:
Embarked Sex
C female 28.344262
male 32.998841
Q female 24.291667
male 30.937500
S female 27.771505
male 30.291440
Name: Age, dtype: float64
前为止, groupby
的分组依据都是直接可以从列中按照名字获取的,那如果希望通过一定的复杂逻辑来分组。
例:根据乘客票价是否超过平均值来分组,同样还是计算年龄的均值。
condition = df.Fare > df.Fare.mean()
df.groupby(condition)['Age'].mean()
Out[13]:
Fare
False 28.554143
True 33.021421
Name: Age, dtype: float64
练一练
根据上下四分位数分割,将票价分为high、normal、low三组,统计年龄的均值。
data = df.copy()
def fenzhu(x):
...: if x <= df.Fare.quantile(0.25):
...: return('low')
...: if x >= df.Fare.quantile(0.75):
...: return('high')
...: else:
...: return('normal')
...:
condition = df.Fare.apply(fenzhu)
data.groupby(condition)['Age'].mean()
Out[10]:
Fare
high 32.030204
low 28.328671
normal 29.003333
Name: Age, dtype: float64
#果然有钱人的年龄普遍比较大<.<.
从索引可以看出,其实最后产生的结果就是按照条件列表中元素的值(此处是 True
和 False
)来分组,下面用随机传入字母序列来验证这一想法:
item = np.random.choice(list('abc'),df.shape[0])
df.groupby(item)['Age'].mean()
Out[14]:
a 29.659553
b 29.627702
c 29.823864
Name: Age, dtype: float64
此处的索引就是原先item中的元素,如果传入多个序列进入 groupby
,那么最后分组的依据就是这两个序列对应行的唯一组合:
df.groupby([condition,item])['Age'].mean()
Out[18]:
Fare
high a 31.666667
b 32.347937
c 32.155172
low a 28.105769
b 26.936170
c 30.079545
normal a 29.073529
b 29.302536
c 28.582627
Name: Age, dtype: float64
由此可以看出,之前传入列名只是一种简便的记号,事实上等价于传入的是一个或多个列,最后分组的依据来自于数据来源组合的unique值,通过 drop_duplicates
就能知道具体的组类别:
df[['Embarked','Sex']].drop_duplicates()
Out[19]:
Embarked Sex
0 S male
1 C female
2 S female
5 Q male
22 Q female
26 C male
61 NaN female
df.groupby([df['Embarked'],df['Sex']])['Age'].mean()
Out[20]:
Embarked Sex
C female 28.344262
male 32.998841
Q female 24.291667
male 30.937500
S female 27.771505
male 30.291440
Name: Age, dtype: float64
3.Groupby对象
能够注意到,最终具体做分组操作时,所调用的方法都来自于 pandas
中的 groupby
对象,这个对象上定义了许多方法,也具有一些方便的属性。
gb = df.groupby(['Embarked','Sex'])
gb
Out[22]: <pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001E218071610>
gb.ngroups
Out[23]: 6 #通过ngroups属性,得到分组个数
res = gb.groups
res.keys() #字典的值由于是索引,元素个数过多,此处只展示字典的键
Out[25]: dict_keys([('S', 'male'), ('C', 'female'), ('S', 'female'), ('Q', 'male'), ('Q', 'female'), ('C', 'male'), (nan, 'female')])
练一练
上一小节介绍了可以通过
drop_duplicates
得到具体的组类别,现请用groups
属性完成类似的功能。
df.groupby(['Embarked','Sex']).groups.keys()
Out[26]: dict_keys([('S', 'male'), ('C', 'female'), ('S', 'female'), ('Q', 'male'), ('Q', 'female'), ('C', 'male'), (nan, 'female')])
当size
作为DataFrame
的属性时,返回的是表长乘以表宽的大小,但在groupby
对象上表示统计每个组的元素个数:
gb.size()
Out[27]:
Embarked Sex
C female 73
male 95
Q female 36
male 41
S female 203
male 441
dtype: int64
通过 get_group
方法可以直接获取所在组对应的行,此时必须知道组的具体名字:
gb.get_group(('C','male')).iloc[:3,:3]
Out[28]:
PassengerId Survived Pclass
26 27 0 3
30 31 0 1
34 35 0 1
这里列出了2个属性和2个方法,而先前的 mean
、 median
都是 groupby
对象上的方法,这些函数和许多其他函数的操作具有高度相似性,将在之后的小节进行专门介绍。
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('Sex')['Age']
gb.idxmax()
Out[30]:
Sex
female 275
male 630
Name: Age, dtype: int64
gb.quantile(0.95)
Out[31]:
Sex
female 53.0
male 59.0
Name: Age, dtype: float64
这些聚合函数当传入的数据来源包含多个列时,将按照列进行迭代计算:
gb = df.groupby('Sex')[['Age','Fare']]
gb.max()
Out[33]:
Age Fare
Sex
female 63.0 512.3292
male 80.0 512.3292
2.agg方法
虽然在groupby
对象上定义了许多方便的函数,但仍然有以下不便之处:
- 无法同时使用多个函数
- 无法对特定的列使用特定的聚合函数
- 无法使用自定义的聚合函数
- 无法直接对结果的列名在聚合前进行自定义命名
下面说明如何通过agg
函数解决这四类问题:
【a】使用多个函数
当使用多个聚合函数时,需要用列表的形式把内置聚合函数的对应的字符串传入,先前提到的所有字符串都是合法的。
gb.agg(['sum','idxmax','skew'])
Out[35]:
Age Fare
sum idxmax skew sum idxmax skew
Sex
female 7286.00 275 0.206097 13966.6628 258 3.277623
male 13919.17 630 0.475318 14727.2865 679 6.621515
从结果看,此时的列索引为多级索引,第一层为数据源,第二层为使用的聚合方法,分别逐一对列使用聚合,因此结果为6列。
【b】对特定的列使用特定的聚合函数
对于方法和列的特殊对应,可以通过构造字典传入 agg
中实现,其中字典以列名为键,以聚合字符串或字符串列表为值。
gb.agg({'Age':['mean','max'],'Fare':'count'})
Out[36]:
Age Fare
mean max count
Sex
female 27.915709 63.0 314
male 30.726645 80.0 577
练一练
请使用【b】中的传入字典的方法完成【a】中等价的聚合任务。
gb.agg({'Age':['sum','idxmax','skew'],'Fare':['sum','idxmax','skew']})
Out[37]:
Age Fare
sum idxmax skew sum idxmax skew
Sex
female 7286.00 275 0.206097 13966.6628 258 3.277623
male 13919.17 630 0.475318 14727.2865 679 6.621515
【c】使用自定义函数
在 agg
中可以使用具体的自定义函数, 需要注意传入函数的参数是之前数据源中的列,逐列进行计算 。下面计算年龄和票价的极差:
gb.agg(lambda x : x.mean()-x.min())
Out[38]:
Age Fare
Sex
female 27.165709 37.729818
male 30.306645 25.523893
练一练
在
groupby
对象中可以使用describe
方法进行统计信息汇总,请同时使用多个聚合函数,完成与该方法相同的功能。
gb.describe()
Out[39]:
Age ... Fare
count mean std min ... 25% 50% 75% max
Sex ...
female 261.0 27.915709 14.110146 0.75 ... 12.071875 23.0 55.00 512.3292
male 453.0 30.726645 14.678201 0.42 ... 7.895800 10.5 26.55 512.3292
[2 rows x 16 columns]
gb.agg(['count','mean','std','min',('25%',lambda x:x.quantile(0.25)),('50%','quantile'),('75%',lambda x:x.quantile(0.75)),'max'])
Out[40]:
Age ... Fare
count mean std min ... 25% 50% 75% max
Sex ...
female 261 27.915709 14.110146 0.75 ... 12.071875 23.0 55.00 512.3292
male 453 30.726645 14.678201 0.42 ... 7.895800 10.5 26.55 512.3292
[2 rows x 16 columns]
由于传入的是序列,因此序列上的方法和属性都是可以在函数中使用的,只需保证返回值是标量即可。下面的例子是指,如果组的指标均值,超过该指标的总体均值,返回High,否则返回Low。
def my_func(s):
...: res = 'Age'
...: if s.mean() <= df[s.name].mean():
...: res = 'Low'
...: return res
...:
gb.agg(my_func)
Out[42]:
Age Fare
Sex
female Low None
male None Low
【d】聚合结果重命名
如果想要对聚合结果的列名进行重命名,只需要将上述函数的位置改写成元组,元组的第一个元素为新的名字,第二个位置为原来的函数,包括聚合字符串和自定义函数,现举若干例子说明:
gb.agg([('range', lambda x: x.max()-x.min()), ('my_sum', 'sum')])
Out[43]:
Age Fare
range my_sum range my_sum
Sex
female 62.25 7286.00 505.5792 13966.6628
male 79.58 13919.17 512.3292 14727.2865
另外需要注意,使用对一个或者多个列使用单个聚合的时候,重命名需要加方括号,否则就不知道是新的名字还是手误输错的内置函数字符串:
gb.agg([('my_sum', 'sum')])
Out[45]:
Age Fare
my_sum my_sum
Sex
female 7286.00 13966.6628
male 13919.17 14727.2865
交换和过滤
1.交换函数与transform方法
变换函数的返回值为同长度的序列,最常用的内置变换函数是累计函数: cumcount/cumsum/cumprod/cummax/cummin
,它们的使用方式和聚合函数类似,只不过完成的是组内累计操作。此外在 groupby
对象上还定义了填充类和滑窗类的变换函数,这些函数的一般形式将会分别在第七章和第十章中讨论,此处略过。
gb.cummax().head()
Out[46]:
Age Fare
0 22.0 7.2500
1 38.0 71.2833
2 38.0 71.2833
3 38.0 71.2833
4 35.0 8.0500
当用自定义变换时需要使用 transform
方法,被调用的自定义函数, 其传入值为数据源的序列 ,与 agg
的传入类型是一致的,其最后的返回结果是行列索引与数据源一致的 DataFrame
。
现对年龄和票价进行分组标准化,即减去组均值后除以组的标准差:
gb.transform(lambda x: (x-x.mean())/x.std()).head()
Out[49]:
Age Fare
0 -0.594531 -0.423612
1 0.714684 0.462147
2 -0.135768 -0.630280
3 0.502071 0.148630
4 0.291136 -0.405067
前面提到了 transform
只能返回同长度的序列,但事实上还可以返回一个标量,这会使得结果被广播到其所在的整个组,这种 标量广播 的技巧在特征工程中是非常常见的。例如,构造两列新特征来分别表示样本所在性别组的年龄均值和票价均值:
gb.transform('mean').head()
Out[50]:
Age Fare
0 30.726645 25.523893
1 27.915709 44.479818
2 27.915709 44.479818
3 27.915709 44.479818
4 30.726645 25.523893
2.组索引与过滤
在上一章中介绍了索引的用法,那么索引和过滤有什么区别呢?
过滤在分组中是对于组的过滤,而索引是对于行的过滤,在第三章中的返回值,无论是布尔列表还是元素列表或者位置列表,本质上都是对于行的筛选,即如果满足筛选条件的则选入结果的表,否则不选入。
组过滤作为行过滤的推广,指的是如果对一个组的全体所在行进行统计的结果返回True
则会被保留,False
则该组会被过滤,最后把所有未被过滤的组其对应的所在行拼接起来作为DataFrame
返回。
在groupby
对象中,定义了filter
方法进行组的筛选,其中自定义函数的输入参数为数据源构成的DataFrame
本身,在之前例子中定义的groupby
对象中,传入的就是df[['Height', 'Weight']]
,因此所有表方法和属性都可以在自定义函数中相应地使用,同时只需保证自定义函数的返回为布尔值即可。
例如,在原表中通过过滤得到所有容量大于100的组:
gb.filter(lambda x : x.shape[0] > 100).head()
Out[51]:
Age Fare
0 22.0 7.2500
1 38.0 71.2833
2 26.0 7.9250
3 35.0 53.1000
4 35.0 8.0500
跨列分组
1.apply的引入
之前几节介绍了三大分组操作,但事实上还有一种常见的分组场景,无法用前面介绍的任何一种方法处理,例如现在如下定义身体质量指数BMI:
$$
BMI=
Weight
/
Height^2
$$
其中体重和身高的单位分别为千克和米,需要分组计算组BMI的均值。
首先,这显然不是过滤操作,因此 filter
不符合要求;其次,返回的均值是标量而不是序列,因此 transform
不符合要求;最后,似乎使用 agg
函数能够处理,但是之前强调过聚合函数是逐列处理的,而不能够 多列数据同时处理 。由此,引出了 apply
函数来解决这一问题。
2.apply的使用
在设计上, apply
的自定义函数传入参数与 filter
完全一致,只不过后者只允许返回布尔值。现如下解决上述计算问题:
In [38]: def BMI(x):
....: Height = x['Height']/100
....: Weight = x['Weight']
....: BMI_value = Weight/Height**2
....: return BMI_value.mean()
....:
In [39]: gb.apply(BMI)
Out[39]:
Gender
Female 18.860930
Male 24.318654
dtype: float64
除了返回标量之外, apply
方法还可以返回一维 Series
和二维 DataFrame
,但它们产生的数据框维数和多级索引的层数应当如何变化?下面举三组例子就非常容易明白结果是如何生成的:
【a】标量情况:结果得到的是 Series
,索引与 agg
的结果一致
gb = df.groupby(['Sex','Pclass'])[['Age','Fare']]
gb.apply(lambda x:0)
Out[54]:
Sex Pclass
female 1 0
2 0
3 0
male 1 0
2 0
3 0
dtype: int64
gb.apply(lambda x : [0,0])
Out[55]:
Sex Pclass
female 1 [0, 0]
2 [0, 0]
3 [0, 0]
male 1 [0, 0]
2 [0, 0]
3 [0, 0]
dtype: object
【b】 Series
情况:得到的是 DataFrame
,行索引与标量情况一致,列索引为 Series
的索引
gb.apply(lambda x: pd.Series([0,0],index=['a','b']))
Out[56]:
a b
Sex Pclass
female 1 0 0
2 0 0
3 0 0
male 1 0 0
2 0 0
3 0 0
【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')])))
Out[57]:
w y
x z
Sex Pclass
female 1 a 1.0 1.0
b 1.0 1.0
2 a 1.0 1.0
b 1.0 1.0
3 a 1.0 1.0
b 1.0 1.0
male 1 a 1.0 1.0
b 1.0 1.0
2 a 1.0 1.0
b 1.0 1.0
3 a 1.0 1.0
b 1.0 1.0
最后需要强调的是, apply
函数的灵活性是以牺牲一定性能为代价换得的,除非需要使用跨列处理的分组处理,否则应当使用其他专门设计的 groupby
对象方法,否则在性能上会存在较大的差距。同时,在使用聚合函数和变换函数时,也应当优先使用内置函数,它们经过了高度的性能优化,一般而言在速度上都会快于用自定义函数来实现。