若是Pandas只是能把一些数据变成 dataframe
这样优美的格式,那么Pandas毫不会成为叱咤风云的数据分析中心组件。由于在数据分析过程当中,描述数据是经过一些列的统计指标实现的,分析结果也须要由具体的分组行为,对各组横向纵向对比。html
GroupBy
就是这样的一个有力武器。事实上,SQL语言在Pandas出现的几十年前就成为了高级数据分析人员的标准工具,很大一部分缘由正是由于它有标准的SELECT xx FROM xx WHERE condition GROUP BY xx HAVING condition
范式。python
感谢 Wes Mckinney及其团队,除了SQL以外,咱们多了一个更灵活、适应性更强的工具,而非困在SQL Shell或Python里步履沉重。sql
SELECT Column1, Column2, mean(Column3), sum(Column4)
FROM SomeTable
WHERE Condition 1
GROUP BY Column1, Column2
HAVING Condition2数组
df [Condition1].groupby([Column1, Column2], as_index=False).agg({Column3: "mean", Column4: "sum"}).filter(Condition2)app
GroupBy能够分解为三个步骤:dom
那么,这一套行云流水的动做是如何完成的呢?ide
groupby
实现agg
、apply
、transform
、filter
实现具体的操做concat
等实现其中,在apply这一步,一般由如下四类操做:函数
注意,这里讨论的apply
,agg
,transform
,filter
方法都是限制在 pandas.core.groupby.DataFrameGroupBy
里面,不能跟 pandas.core.groupby.DataFrame
混淆。工具
先导入须要用到的模块大数据
import numpy as np import pandas as pd import sys, traceback from itertools import chain
df_0 = pd.DataFrame({'A': list(chain(*[['foo', 'bar']*4])), 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], 'C': np.random.randn(8), 'D': np.random.randn(8)})
df_0
A | B | C | D | |
---|---|---|---|---|
0 | foo | one | 1.145852 | 0.210586 |
1 | bar | one | -1.343518 | -2.064735 |
2 | foo | two | 0.544624 | 1.125505 |
3 | bar | three | 1.090288 | -0.296160 |
4 | foo | two | -1.854274 | 1.348597 |
5 | bar | two | -0.246072 | -0.598949 |
6 | foo | one | 0.348484 | 0.429300 |
7 | bar | three | 1.477379 | 0.917027 |
df_01 = df_0.copy() df_01.groupby(["A", "B"], as_index=False, sort=False).agg({"C": "sum", "D": "mean"})
A | B | C | D | |
---|---|---|---|---|
0 | foo | one | 1.494336 | 0.319943 |
1 | bar | one | -1.343518 | -2.064735 |
2 | foo | two | -1.309649 | 1.237051 |
3 | bar | three | 2.567667 | 0.310433 |
4 | bar | two | -0.246072 | -0.598949 |
df_02 = df_0.copy() df_02.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"}).reset_index()
A | B | C | D | |
---|---|---|---|---|
0 | bar | one | -1.343518 | -2.064735 |
1 | bar | three | 2.567667 | 0.310433 |
2 | bar | two | -0.246072 | -0.598949 |
3 | foo | one | 1.494336 | 0.319943 |
4 | foo | two | -1.309649 | 1.237051 |
as_index=False
参数是一个好的习惯,由于若是dataframe很是巨大(好比达到GB以上规模)时,先生成一个Groupby对象,而后再调用reset_index()
会有额外的时间消耗。若是要获得一个多层索引的数据框,使用默认的as_index=True
便可,例以下面的例子:
df_03 = df_0.copy() df_03.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"})
C | D | ||
---|---|---|---|
A | B | ||
bar | one | -1.343518 | -2.064735 |
three | 2.567667 | 0.310433 | |
two | -0.246072 | -0.598949 | |
foo | one | 1.494336 | 0.319943 |
two | -1.309649 | 1.237051 |
注意,as_index
仅当作aggregation
操做时有效,若是是其余操做,例如transform
,指定这个参数是无效的
df_04 = df_0.copy() df_04.groupby(["A", "B"], as_index=True).transform(lambda x: x * x)
C | D | |
---|---|---|
0 | 1.312976 | 0.044347 |
1 | 1.805040 | 4.263130 |
2 | 0.296616 | 1.266761 |
3 | 1.188727 | 0.087711 |
4 | 3.438331 | 1.818714 |
5 | 0.060552 | 0.358740 |
6 | 0.121441 | 0.184298 |
7 | 2.182650 | 0.840938 |
能够看到,咱们获得了一个和df_0同样长度的新dataframe
,同时咱们还但愿A,B能成为索引,但这并无生效。
pd.Grouper
pd.Grouper
比 groupby
更强大、更灵活,它不只支持普通的分组,还支持按照时间进行升采样或降采样分组
df_1 = pd.read_excel("dataset\sample-salesv3.xlsx") df_1["date"] = pd.to_datetime(df_1["date"])
df_1.head()
account number | name | sku | quantity | unit price | ext price | date | |
---|---|---|---|---|---|---|---|
0 | 740150 | Barton LLC | B1-20000 | 39 | 86.69 | 3380.91 | 2014-01-01 07:21:51 |
1 | 714466 | Trantow-Barrows | S2-77896 | -1 | 63.16 | -63.16 | 2014-01-01 10:00:47 |
2 | 218895 | Kulas Inc | B1-69924 | 23 | 90.70 | 2086.10 | 2014-01-01 13:24:58 |
3 | 307599 | Kassulke, Ondricka and Metz | S1-65481 | 41 | 21.05 | 863.05 | 2014-01-01 15:05:22 |
4 | 412290 | Jerde-Hilpert | S2-34077 | 6 | 83.21 | 499.26 | 2014-01-01 23:26:55 |
【例子】计算每月的ext price总和
df_1.set_index("date").resample("M")["ext price"].sum()
date 2014-01-31 185361.66 2014-02-28 146211.62 2014-03-31 203921.38 2014-04-30 174574.11 2014-05-31 165418.55 2014-06-30 174089.33 2014-07-31 191662.11 2014-08-31 153778.59 2014-09-30 168443.17 2014-10-31 171495.32 2014-11-30 119961.22 2014-12-31 163867.26 Freq: M, Name: ext price, dtype: float64
df_1.groupby(pd.Grouper(key="date", freq="M"))["ext price"].sum()
date 2014-01-31 185361.66 2014-02-28 146211.62 2014-03-31 203921.38 2014-04-30 174574.11 2014-05-31 165418.55 2014-06-30 174089.33 2014-07-31 191662.11 2014-08-31 153778.59 2014-09-30 168443.17 2014-10-31 171495.32 2014-11-30 119961.22 2014-12-31 163867.26 Freq: M, Name: ext price, dtype: float64
两种写法都获得了相同的结果,而且看上去第二种写法彷佛有点儿难以理解。再看一个例子
【例子】计算每一个客户每月的ext price总和
df_1.set_index("date").groupby("name")["ext price"].resample("M").sum().head(20)
name date Barton LLC 2014-01-31 6177.57 2014-02-28 12218.03 2014-03-31 3513.53 2014-04-30 11474.20 2014-05-31 10220.17 2014-06-30 10463.73 2014-07-31 6750.48 2014-08-31 17541.46 2014-09-30 14053.61 2014-10-31 9351.68 2014-11-30 4901.14 2014-12-31 2772.90 Cronin, Oberbrunner and Spencer 2014-01-31 1141.75 2014-02-28 13976.26 2014-03-31 11691.62 2014-04-30 3685.44 2014-05-31 6760.11 2014-06-30 5379.67 2014-07-31 6020.30 2014-08-31 5399.58 Name: ext price, dtype: float64
df_1.groupby(["name", pd.Grouper(key="date",freq="M")])["ext price"].sum().head(20)
name date Barton LLC 2014-01-31 6177.57 2014-02-28 12218.03 2014-03-31 3513.53 2014-04-30 11474.20 2014-05-31 10220.17 2014-06-30 10463.73 2014-07-31 6750.48 2014-08-31 17541.46 2014-09-30 14053.61 2014-10-31 9351.68 2014-11-30 4901.14 2014-12-31 2772.90 Cronin, Oberbrunner and Spencer 2014-01-31 1141.75 2014-02-28 13976.26 2014-03-31 11691.62 2014-04-30 3685.44 2014-05-31 6760.11 2014-06-30 5379.67 2014-07-31 6020.30 2014-08-31 5399.58 Name: ext price, dtype: float64
此次,第二种写法远比第一种写法清爽、便于理解。这种按照特定字段和时间采样的混合分组,请优先考虑用pd.Grouper
若是只是作完拆分动做,没有作后续的apply,获得的是一个groupby
对象。这里讨论下如何访问拆分出来的组
主要方法为:
groups
get_group
df_2 = pd.DataFrame({'X': ['A', 'B', 'A', 'B'], 'Y': [1, 4, 3, 2]}) df_2
X | Y | |
---|---|---|
0 | A | 1 |
1 | B | 4 |
2 | A | 3 |
3 | B | 2 |
groups
方法能够看到全部的组df_2.groupby("X").groups
{'A': Int64Index([0, 2], dtype='int64'), 'B': Int64Index([1, 3], dtype='int64')}
get_group
方法能够访问到指定的组df_2.groupby("X", as_index=True).get_group(name="A")
X | Y | |
---|---|---|
0 | A | 1 |
2 | A | 3 |
注意,get_group
方法中,name
参数只能传递单个str
,不能够传入list
,尽管Pandas中的其余地方经常能看到这类传参。若是是多列作主键的拆分,能够传入tuple
。
for name, group in df_2.groupby("X"): print(name) print(group,"\n")
A X Y 0 A 1 2 A 3 B X Y 1 B 4 3 B 2
这里介绍一个小技巧,若是你获得一个<pandas.core.groupby.groupby.DataFrameGroupBy object
对象,想要将它还原成其本来的 dataframe
,有一个很是简便的方法值得一提:
gropbyed_object.apply(lambda x: x)
囿于篇幅,就不对API逐个解释了,这里仅指出最容易忽视也最容易出错的三个参数
参数 | 注意事项 |
---|---|
level | 仅做用于层次化索引的数据框时有效 |
as_index | 仅对数据框作 agg 操做时有效, |
group_keys | 仅在调用 apply 时有效 |
拆分完成后,能够对各个组作一些的操做,整体说来能够分为如下四类:
先总括地对比下这四类操做
Series
压缩成一个标量值的都是agg
操做,例如求和、求均值、求极值等统计计算groupby
对象作变换,获得子集或一个新的数据框的操做是apply
或transform
filter
apply
和 transform
有那么一点类似,下文会重点剖析两者
agg
和apply
均可以对特定列的数据传入函数,而且依照函数进行计算。可是区别在于,agg
更加灵活高效,能够一次完成操做。而apply
须要展转屡次才能完成相同操做。
df_3 = pd.DataFrame({"name":["Foo", "Bar", "Foo", "Bar"], "score":[80,80,95,70]}) df_3
name | score | |
---|---|---|
0 | Foo | 80 |
1 | Bar | 80 |
2 | Foo | 95 |
3 | Bar | 70 |
咱们须要计算出每一个人的总分、最高分、最低分
(1)使用apply
方法
df_3.groupby("name", sort=False).score.apply(lambda x: x.sum())
name Foo 175 Bar 150 Name: score, dtype: int64
df_3.groupby("name", sort=False).score.apply(lambda x: x.max())
name Foo 95 Bar 80 Name: score, dtype: int64
df_3.groupby("name", sort=False).score.apply(lambda x: x.min())
name Foo 80 Bar 70 Name: score, dtype: int64
显然,咱们展转操做了3次,而且还须要额外一次操做(将所获得的三个值粘合起来)
(2)使用agg
方法
df_3.groupby("name", sort=False).agg({"score": [np.sum, np.max, np.min]})
score | |||
---|---|---|---|
sum | amax | amin | |
name | |||
Foo | 175 | 95 | 80 |
Bar | 150 | 80 | 70 |
小结 agg
一次能够对多个列独立地调用不一样的函数,而apply
一次只能对多个列调用相同的一个函数。
transform
做用于数据框自身,而且返回变换后的值。返回的对象和原对象拥有相同数目的行,但能够扩展列。注意返回的对象不是就地修改了原对象,而是建立了一个新对象。也就是说原对象没变。
df_4 = pd.DataFrame({'A': range(3), 'B': range(1, 4)}) df_4
A | B | |
---|---|---|
0 | 0 | 1 |
1 | 1 | 2 |
2 | 2 | 3 |
df_4.transform(lambda x: x + 1)
A | B | |
---|---|---|
0 | 1 | 2 |
1 | 2 | 3 |
2 | 3 | 4 |
能够对数据框先分组,而后对各组赋予一个变换,例如元素自增1。下面这个例子意义不大,能够直接作变换。
df_2.groupby("X").transform(lambda x: x + 1)
Y | |
---|---|
0 | 2 |
1 | 5 |
2 | 4 |
3 | 3 |
下面举一个更实际的例子
df_5 = pd.read_csv(r"dataset\tips.csv") df_5.head()
total_bill | tip | sex | smoker | day | time | size | |
---|---|---|---|---|---|---|---|
0 | 16.99 | 1.01 | Female | No | Sun | Dinner | 2 |
1 | 10.34 | 1.66 | Male | No | Sun | Dinner | 3 |
2 | 21.01 | 3.50 | Male | No | Sun | Dinner | 3 |
3 | 23.68 | 3.31 | Male | No | Sun | Dinner | 2 |
4 | 24.59 | 3.61 | Female | No | Sun | Dinner | 4 |
如今咱们想知道天天,各数值列的均值
对比如下 agg
和 transform
两种操做
df_5.groupby("day").aggregate("mean")
total_bill | tip | size | |
---|---|---|---|
day | |||
Fri | 17.151579 | 2.734737 | 2.105263 |
Sat | 20.441379 | 2.993103 | 2.517241 |
Sun | 21.410000 | 3.255132 | 2.842105 |
Thur | 17.682742 | 2.771452 | 2.451613 |
df_5.groupby('day').transform(lambda x : x.mean()).total_bill.unique()
array([21.41 , 20.44137931, 17.68274194, 17.15157895])
观察得知,两种操做是相同的,都是对各个小组求均值。所不一样的是,agg
方法仅返回4行(即压缩后的统计值),而transform
返回一个和原数据框一样长度的新数据框。
transform
和 apply
的不一样主要体如今两方面:
apply
对于每一个组,都是同时在全部列上面调用函数;而 transform
是对每一个组,依次在每一列上调用函数apply
能够返回标量、Series
、dataframe
——取决于你在什么上面调用了apply
方法;而 transform
只能返回一个相似于数组的序列,例如一维的 Series
、array
、list
,而且最重要的是,要和原始组有一样的长度,不然会引起错误。【例子】经过打印对象的类型来对比两种方法的工做对象
df_6 = pd.DataFrame({'State':['Texas', 'Texas', 'Florida', 'Florida'], 'a':[4,5,1,3], 'b':[6,10,3,11]}) df_6
State | a | b | |
---|---|---|---|
0 | Texas | 4 | 6 |
1 | Texas | 5 | 10 |
2 | Florida | 1 | 3 |
3 | Florida | 3 | 11 |
def inspect(x): print(type(x)) print(x)
df_6.groupby("State").apply(inspect)
<class 'pandas.core.frame.DataFrame'> State a b 2 Florida 1 3 3 Florida 3 11 <class 'pandas.core.frame.DataFrame'> State a b 2 Florida 1 3 3 Florida 3 11 <class 'pandas.core.frame.DataFrame'> State a b 0 Texas 4 6 1 Texas 5 10
从打印结果咱们清晰地看到两点:apply
每次做用的对象是一个 dataframe
,其次第一个组被计算了两次,这是由于pandas
会经过这种机制来对比是否有更快的方式完成后面剩下组的计算。
df_6.groupby("State").transform(inspect)
<class 'pandas.core.series.Series'> 2 1 3 3 Name: a, dtype: int64 <class 'pandas.core.series.Series'> 2 3 3 11 Name: b, dtype: int64 <class 'pandas.core.frame.DataFrame'> a b 2 1 3 3 3 11 <class 'pandas.core.series.Series'> 0 4 1 5 Name: a, dtype: int64 <class 'pandas.core.series.Series'> 0 6 1 10 Name: b, dtype: int64
从打印结果咱们也清晰地看到两点:transform
每次只计算一列;会出现计算了一个组总体的状况,这有点使人费解,待研究。
从上面的对比,咱们直接获得了一个有用的警示:不要传一个同时涉及到多列的函数给transform
方法,由于那么作只会获得错误。例以下面的代码所示:
def subtract(x): return x["a"] - x["b"]
try: df_6.groupby("State").transform(subtract) except Exception: exc_type, exc_value, exc_traceback = sys.exc_info() formatted_lines = traceback.format_exc().splitlines() print(formatted_lines[-1])
KeyError: ('a', 'occurred at index a')
另外一个警示则是:在使用 transform
方法的时候,不要去试图修改返回结果的长度,那样不只会引起错误,并且traceback的信息很是隐晦,极可能你须要花很长时间才能真正意识到错误所在。
def return_more(x): return np.arange(3)
try: df_6.groupby("State").transform(return_more) except Exception: exc_type, exc_value, exc_traceback = sys.exc_info() formatted_lines = traceback.format_exc().splitlines() print(formatted_lines[-1])
ValueError: Length mismatch: Expected axis has 6 elements, new values have 4 elements
这个报错信息有点别扭,期待返回6个元素,可是返回的结果只有4个元素;其实,应该说预期的返回为4个元素,可是如今却返回6个元素,这样比较容易理解错误所在。
最后,让咱们以一条有用的经验结束这个talk:若是你确信本身想要的操做时同时做用于多列,而且速度最好还很快,请不要用transform
方法,Talk9
有一个这方面的好例子。
(1)一次对全部列调用多个函数
df_0.groupby("A").agg([np.sum, np.mean, np.min])
C | D | |||||
---|---|---|---|---|---|---|
sum | mean | amin | sum | mean | amin | |
A | ||||||
bar | 0.978077 | 0.244519 | -1.343518 | -2.042817 | -0.510704 | -2.064735 |
foo | 0.184686 | 0.046172 | -1.854274 | 3.113988 | 0.778497 | 0.210586 |
(2)一次对特定列调用多个函数
df_0.groupby("A")["C"].agg([np.sum, np.mean, np.min])
sum | mean | amin | |
---|---|---|---|
A | |||
bar | 0.978077 | 0.244519 | -1.343518 |
foo | 0.184686 | 0.046172 | -1.854274 |
(3)对不一样列调用不一样函数
df_0.groupby("A").agg({"C": [np.sum, np.mean], "D": [np.max, np.min]})
C | D | |||
---|---|---|---|---|
sum | mean | amax | amin | |
A | ||||
bar | 0.978077 | 0.244519 | 0.917027 | -2.064735 |
foo | 0.184686 | 0.046172 | 1.348597 | 0.210586 |
df_0.groupby("A").agg({"C": "sum", "D": "min"})
C | D | |
---|---|---|
A | ||
bar | 0.978077 | -2.064735 |
foo | 0.184686 | 0.210586 |
(4)对同一列调用不一样函数,而且直接重命名
df_0.groupby("A")["C"].agg([("Largest", "max"), ("Smallest", "min")])
Largest | Smallest | |
---|---|---|
A | ||
bar | 1.477379 | -1.343518 |
foo | 1.145852 | -1.854274 |
(5)对多个列调用同一个函数
agg_keys = {}.fromkeys(["C", "D"], "sum") df_0.groupby("A").agg(agg_keys)
C | D | |
---|---|---|
A | ||
bar | 0.978077 | -2.042817 |
foo | 0.184686 | 3.113988 |
(6)注意agg
会忽略缺失值,这在计数时须要加以注意
df_7 = pd.DataFrame({"ID":["A","A","A","B","B"], "Num": [1,np.nan, 1,1,1]}) df_7
ID | Num | |
---|---|---|
0 | A | 1.0 |
1 | A | NaN |
2 | A | 1.0 |
3 | B | 1.0 |
4 | B | 1.0 |
df_7.groupby("ID").agg({"Num":"count"})
Num | |
---|---|
ID | |
A | 2 |
B | 2 |
注意:Pandas
中的 count
,sum
,mean
,median
,std
,var
,min
,max
等函数都用C语言优化过。因此,仍是那句话,若是你在大数据集上使用agg
,最好使用这些函数而非从numpy
那里借用np.sum
等方法,一个缓慢的程序是由每一步的缓慢积累而成的。
一般,在对一个 dataframe
分组而且完成既定的操做以后,能够直接返回结果,也能够视需求对结果做一层过滤。这个过滤通常都是指 filter
操做,可是务必要理解清楚本身到底须要对组做过滤仍是对组内的每一行做过滤。这个Talk就来讨论过滤这个话题。
【例子】找出每门课程考试分数低于这门课程平均分的学生
df_8 = pd.DataFrame({"Subject": list(chain(*[["Math"]*3,["Computer"]*3])), "Student": list(chain(*[["Chan", "Ida", "Ada"]*2])), "Score": [80,90,85,90,85,95]})
df_8
Subject | Student | Score | |
---|---|---|---|
0 | Math | Chan | 80 |
1 | Math | Ida | 90 |
2 | Math | Ada | 85 |
3 | Computer | Chan | 90 |
4 | Computer | Ida | 85 |
5 | Computer | Ada | 95 |
这样一个需求是否适合用 filter
来处理呢?咱们试试看:
try: df_8.groupby("Subject").filter(lambda x: x["Score"] < x["Score"].mean()) except Exception: exc_type, exc_value, exc_traceback = sys.exc_info() formatted_lines = traceback.format_exc().splitlines() print(formatted_lines[-1])
TypeError: filter function returned a Series, but expected a scalar bool
显然不行,由于 filter
实际上作的事情是要么留下这个组,要么过滤掉这个组。咱们在这里弄混淆的东西,和咱们初学 SQL
时弄混 WHERE
和 HAVING
是一回事。就像须要记住 HAVING
是一个组内语法同样,请记住 filter
是一个组内方法。
咱们先解决这个例子,正确的作法以下:
df_8.groupby("Subject").apply(lambda g: g[g.Score < g.Score.mean()])
Subject | Student | Score | ||
---|---|---|---|---|
Subject | ||||
Computer | 4 | Computer | Ida | 85 |
Math | 0 | Math | Chan | 80 |
而关于 filter
,咱们援引官方文档上的例子做为对比
df_9 = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar', 'foo', 'bar'], 'B' : [1, 2, 3, 4, 5, 6], 'C' : [2.0, 5., 8., 1., 2., 9.]}) df_9
A | B | C | |
---|---|---|---|
0 | foo | 1 | 2.0 |
1 | bar | 2 | 5.0 |
2 | foo | 3 | 8.0 |
3 | bar | 4 | 1.0 |
4 | foo | 5 | 2.0 |
5 | bar | 6 | 9.0 |
df_9.groupby('A').filter(lambda x: x['B'].mean() > 3.)
A | B | C | |
---|---|---|---|
1 | bar | 2 | 5.0 |
3 | bar | 4 | 1.0 |
5 | bar | 6 | 9.0 |
df_10 = pd.DataFrame({"ID":["A","A","A","B","B","B"], "Num": [100,np.nan,300,np.nan,500,600]}) df_10
ID | Num | |
---|---|---|
0 | A | 100.0 |
1 | A | NaN |
2 | A | 300.0 |
3 | B | NaN |
4 | B | 500.0 |
5 | B | 600.0 |
df_10.groupby("ID", as_index=False).Num.transform(lambda x: x.fillna(method="ffill")).transform(lambda x: x.fillna(method="bfill"))
Num | |
---|---|
0 | 100.0 |
1 | 100.0 |
2 | 300.0 |
3 | 500.0 |
4 | 500.0 |
5 | 600.0 |
若是dataframe
比较大(超过1GB),transform
+ lambda
方法会比较慢,能够用下面这个方法,速度约比上面的组合快100倍。
df_10.groupby("ID",as_index=False).ffill().groupby("ID",as_index=False).bfill()
ID | Num | |
---|---|---|
0 | A | 100.0 |
1 | A | 100.0 |
2 | A | 300.0 |
3 | B | 500.0 |
4 | B | 500.0 |
5 | B | 600.0 |
参考资料:
https://stackoverflow.com/questions/44864655/pandas-difference-between-apply-and-aggregate-functions
https://stackoverflow.com/questions/27517425/apply-vs-transform-on-a-group-object
https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html