pandas中groupby的相关笔记

pandas中groupby的相关笔记

• 使用jupyter notebook

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.randint(0,15,(5,2)),columns=['nI','nII'])

df

	nI	nII
0	8	14
1	1	9
2	10	1
3	13	12
4	3	0

df.sum(),df.sum(axis=1)

(nI     35
 nII    36
 dtype: int64,
 0    22
 1    10
 2    11
 3    25
 4     3
 dtype: int64)

df.mean(),df.mean(axis=1)

(nI     7.0
 nII    7.2
 dtype: float64,
 0    11.0
 1     5.0
 2     5.5
 3    12.5
 4     1.5
 dtype: float64)

df.describe()

	nI	nII
count	5.000000	5.000000
mean	7.000000	7.200000
std	4.949747	6.379655
min	1.000000	0.000000
25%	3.000000	1.000000
50%	8.000000	9.000000
75%	10.000000	12.000000
max	13.000000	14.000000

df=pd.DataFrame({'key':['A','B','C','A','B','C'],'value':[5,4,3,2,1,0]})
df

	key	value
0	A	5
1	B	4
2	C	3
3	A	2
4	B	1
5	C	0

df.groupby('key')#传递列名(注意：这里key不是索引），生成一个DataFrameGroupBy对象，可看做DataFrame的组合，可迭代。这里表现了其lazy evaluation。

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000027414C02610>

df.groupby('key')['value']#是一个SeriesGroupBy对象，同理就可看做Series的组合，可迭代

<pandas.core.groupby.generic.SeriesGroupBy object at 0x000002741CBD8610>

df.groupby('key').sum()

	value
key
A	7
B	5
C	3

df.groupby('key')['value'].sum()# 理解就是df.groupby('key')可看作特殊的DataFrame组合，使用索引是对每个组使用索引。

key
A    7
B    5
C    3
Name: value, dtype: int64

for key,value in df.groupby('key'):# key 就是分组的依据，value就是所分的组可看作DataFrame。直观理解 group by'key'.可以直接迭代
    print('%s'% value)

  key  value
0   A      5
3   A      2
  key  value
1   B      4
4   B      1
  key  value
2   C      3
5   C      0

for key,value in df.groupby('key')['value']:
    print(value)

0    5
3    2
Name: value, dtype: int64
1    4
4    1
Name: value, dtype: int64
2    3
5    0
Name: value, dtype: int64

groupby：

1. 延迟计算（lazy evaluation），有点像yield。
2. split-apply-combine，如下图 ：
   

对于多层索引，DataFrame.groupby()中使用level参数。
可使用axis参数改变split方向,但是传递的label必须是列名(也不是索引），不能是行名。
可使用group_keys=False来去掉调用apply()方法时的分组名（group keys）.

df2=pd.DataFrame({'key':['A','B','C','A','B','C'],'data1':np.random.randint(2,15,(6,)),'data2':np.random.ranf((6,))})
df2

	key	data1	data2
0	A	12	0.774106
1	B	4	0.260684
2	C	13	0.349387
3	A	6	0.651588
4	B	14	0.645364
5	C	4	0.974801

df2.groupby('key').aggregate(['min',np.median,max])#列表中可以是字符串，函数等。

	data1			data2
	min	median	max	min	median	max
key
A	6	9.0	12	0.651588	0.712847	0.774106
B	4	9.0	14	0.260684	0.453024	0.645364
C	4	8.5	13	0.349387	0.662094	0.974801

df2.groupby('key').aggregate({'data1':min,'data2':'max'})#使用字典对不同组用不同的累计方法。
#df2.groupby('key')['data1'].aggregate(min)#先选取列，再进行操作。

	data1	data2
key
A	6	0.774106
B	4	0.645364
C	4	0.974801

def fun_filter(x):
    print(x)#这里是与transform中的x进行对比。
    return x['data1'].std()>6 #这里返回值应为一个bool数值，所以一般要进行累计操作，若是return x['data1']>6 则返回Series，报错。
df2.groupby('key').filter(fun_filter)#注意是函数名，filter 丢弃不合条件的分组。
#df2.groupby('key').filter(lambda x:x['data1'].std()>6)#filter 里面使用函数或者是lambda表达式。两者结果相同，这里x是df2.groupby('key'),上同.

  key  data1     data2
0   A     12  0.774106
3   A      6  0.651588
  key  data1     data2
1   B      4  0.260684
4   B     14  0.645364
  key  data1     data2
2   C     13  0.349387
5   C      4  0.974801

	key	data1	data2
1	B	4	0.260684
2	C	13	0.349387
4	B	14	0.645364
5	C	4	0.974801

df2.groupby('key').transform(lambda x:x-1)#用法和filter相似，函数或者lambda表达式。但是函数的返回值的形状不能改变。

	data1	data2
0	11	-0.225894
1	3	-0.739316
2	12	-0.650613
3	5	-0.348412
4	13	-0.354636
5	3	-0.025199

def fun_t(x):
    print(x)# 这里与filter中的x进行对比，filter中x更像一个DataFrame对象，有索引，而这里是没有的，若访问行x['data1']将报错.
    return x
df2.groupby('key').transform(fun_t)#综上，transform基本只能整体使用x.

0    12.0
3     6.0
Name: data1, dtype: float64
0    12
3     6
Name: data1, dtype: int32
0    0.774106
3    0.651588
Name: data2, dtype: float64
   data1     data2
0     12  0.774106
3      6  0.651588
   data1     data2
1      4  0.260684
4     14  0.645364
   data1     data2
2     13  0.349387
5      4  0.974801

	data1	data2
0	12	0.774106
1	4	0.260684
2	13	0.349387
3	6	0.651588
4	14	0.645364
5	4	0.974801

df.groupby('key').transform(np.mean)#所使用的函数可以是numpy的ufunc，apply同。注意默认对所有值进行操作，以及广播。

	value
0	3.5
1	2.5
2	1.5
3	3.5
4	2.5
5	1.5

df2.groupby('key').apply(lambda x:x['data1']-x['data2'])#注：lambda表达式，lambda后面是参数，函数返回的是":"后面的表达式的值。
#apply()同上，接受函数和lambda表达式。
#apply()就是可以访问x的行和列的transform().

key   
A    0    11.225894
     3     5.348412
B    1     3.739316
     4    13.354636
C    2    12.650613
     5     3.025199
dtype: float64

任意分组

这里的关键是要理解分组键的概念以及对映射的理解。

df2

	key	data1	data2
0	A	12	0.774106
1	B	4	0.260684
2	C	13	0.349387
3	A	6	0.651588
4	B	14	0.645364
5	C	4	0.974801

L=['first3','first3','first3','mid2','mid2','lastone']#长度相等。
L2=[1,1,2,1,2,1]#这里的L,L2 都是分组键，是新定义的分组的标签
df2.groupby(L).sum()
#列表，数组，Series，索引均可——有点函数的位置实参的感觉
#也可用Series或字典——有点关键字实参的感觉。
#映射型函数

	data1	data2
first3	29	1.384176
lastone	4	0.974801
mid2	20	1.296952

df2.groupby([L,L2]).sum()
#这里的sum（）不能有axis的参数，若要操作,使用apply
#也可以组合使用,形成多级索引,为原来的数据设置不同的列表...即可
#L与L2的顺序很重要，若为[L2,L],则是另一个结果

		data1	data2
first3	1	16	1.034789
	2	13	0.349387
lastone	1	4	0.974801
mid2	1	6	0.651588
	2	14	0.645364

df2

	key	data1	data2
0	A	12	0.774106
1	B	4	0.260684
2	C	13	0.349387
3	A	6	0.651588
4	B	14	0.645364
5	C	4	0.974801

df2.groupby('key').apply(lambda x:np.sum(x,axis=1))#axis=1方向上的求和，我想的实现方法。按理说应该有简单的方法呀？？？

key   
A    0    12.774106
     3     6.651588
B    1     4.260684
     4    14.645364
C    2    13.349387
     5     4.974801
dtype: float64

参考文档