python中数据分组计算_SOTON私人定制：利用Python进行数据分析（分组运算）

数据分析比较常见的步骤是将对数据集进行分组然后应用函数，这步也可以称之为分组运算。Hadley Wickham大神为此创造了一个专用术语“split-apply-combine"，即拆分-应用-合并。那么当我们谈论分组运算的时候，我们其实在谈论什么呢？

Splitting：根据标准对数据进行拆分分组

Applying: 对每组都分别应用一个函数

Combining: 将结果合并新的数据结构

分组运算一般要求的数据存放格式为“长格式”，所以先介绍“长格式”和“宽格式”的转换，然后是分组运算的具体操作。

“长格式“ VS”宽格式“

数据的常见保存方式有两种，长格式（long format）或是宽格式（wide format)

wide format

基因

分生组织

根

花

gene1

582

91

495

gene2

305

3505

33

在宽格式下，类别型变量单独成列。如上的植物的不同部位分为3列，列中的数据表示为表达量。看起来就非常的直观，而且日常生活中也是按照如此方法记录数据。

long format

基因

组织

表达量

gene1

分生组织

582

gene2

分生组织

305

gene1

根

91

gene2

根

3503

gene1

花

492

gene2

花

33

而长结构的数据则是类别型变量定义为专门的一列。通常情况下，关系型数据库（如MySQL)通常以长格式存储数据，这是因为固定架构下随着表中数据的增加或删除， 类别行（如组织）能够增加或减少。

后续的分组操作其实更倾向于数据是以长格式进行保存，所以这里先介绍pandas是如何进行长格式和宽格式之间的转换的。

首先创建一个用于测试的长格式数据，方法如下：

import pandas.util.testing as tm; tm.N = 3

def unpivot(frame):

N, K = frame.shape

data = {'value' : frame.values.ravel('F'),

'variable' : np.asarray(frame.columns).repeat(N),

'date' : np.tile(np.asarray(frame.index), K)}

return pd.DataFrame(data, columns=['date', 'variable', 'value'])

ldata = unpivot(tm.makeTimeDataFrame())

然后把长格式变成宽格式，可认为是把数据的列“旋转” 为行

# 第一种方法： pivot

# pd.pivot(index, columns, values), 对应索引，类别列和数值列

pivoted = ldata.pivot('date','variable','value')

# 第二种方法: unstack

## 先用set_index建立层次化索引

unstacked = ldata.set_index(['date','varibale']).unstack('variable')

再把宽格式变为长格式，也可以认为是把数据的行“旋转”成列。

# 先把unstacked数据还原成普通的DataFrame

wdata = nstacked.reset_index()

wdata.columns = ['date','A','B','C','D']

# 第一种方法:melt

pd.melt(wdata, id_vars=['date'])

# 第二种方法： stack

# 如果原始数据没有索引，需要用set_index重建

wdata.set_index('date').stack()

GroupBy

第一步是将数据集根据一定标准，即分组键，拆分多个组，pandas提供了grouby方法，能够根据如下形式的分组键工作：

列表和数组（Numpy array)，其长度与待分组的轴一致

DataFrame的某个列名的值

字典或Series，提供了待分组轴上的值与分组名(label -> group name)之间的对应关系

根据多层次的轴索引

Python函数，用于轴索引或索引中的各个标签

下面举例说明：

形式一：根据某一列的值，一般是类别型数值

df = DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',

'foo', 'bar', 'foo', 'foo'],

'B' : ['one', 'one', 'two', 'three',

'two', 'two', 'one', 'three'],

'C' : np.random.randn(8),

'D' : np.random.randn(8)})

# 根据A列进行拆分

df.groupby('A')

# 根据A和B列进行拆分

df.groupby(['A','B'])

这会产生一个pandas.core.groupby.DataFrameGroupBy object对象，没有进行实质性的运算操作，只产生了中间信息。你可以查看分组之后每一组的大小

df.groupby(['A','B']).size()

形式二： 根据函数. 下面定义了一个函数根据列名是否属于元音进行拆分

def get_letter_type(letter):

if letter.lower() in 'aeiou':

return 'vowel'

else:

return 'consonant'

grouped = df.groupby(get_letter_type, axis=1).

形式三： 根据层次索引。 不同于R语言data.frame只有一个行或列名，pandas的DataFrame允许多个层次结构的行或列名。

# 构建多层次索引的数据

arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],

['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]

index = pd.MultiIndex.from_arrays(arrays, names=['first', 'second'])

s = pd.Series(np.random.randn(8), index=index)

# 根据不同层次的索引进行分组

level1 = s.groupby(level='first') # 第一层

level2 = s.groupby(level=1) # 第二层

形式四： 根据字典或Series进行分组

可以通过字典定义分组信息的映射。

mapping = {'A':'str','B':'str','C':'values','D':'values','E':'values'}

df.groupby(mapping, axis=1)

形式四： 同时根据行索引和列数值进行分组

df.index = index

df.groupby([pd.Grouper(level='first'),'A']).mean()

分组对象迭代： 上面产生的GroupBy分组对象都是可以进行迭代，会产生一个一组二元元组。

# 对于单键值

for name, group in df.groupby(['A']):

print(name)

print(group)

# 对于多个键值

for (k1,k2), group in df.groupby(['A']):

print(k1,k2)

print(group)

选择分组：我们可以在分组结束后用get_group()提取某个特定的组

df.groupby('A').get_group('foo')

# 下面是结果

A B C D E

first second

bar one foo one 0.709603 -1.023657 -0.321730

baz one foo two 1.495328 -0.279928 -0.297983

foo one foo two 0.495288 -0.563845 -1.774453

qux one foo one 1.649135 -0.274208 1.194536

two foo three -2.194127 3.440418 -0.023144

# 多个组

df.groupby(['A', 'B']).get_group(('bar', 'one'))

Apply

分组步骤较为直接，而应用函数步骤则变化较多。这一步，我们可能会做如下操作：

数据聚合（Aggregation）：分别计算各组的统计信息，如均值，大小等

转换（Transformation）： 对每一组进行特异性的计算，如标准化，缺失值插值等

过滤（Filtration）： 根据统计信息进行筛选，舍弃部分组。

数据聚合：Aggregation

所谓的聚合，也就是数组产生标量值的数据转换过程。我们可以使用mean, count, min, sum等一般性方法，也可以用GroupBy对象创建后的aggregate或等价的agg方法。

grouped = df.groupby('A')

grouped.mean()

# 等价于

grouped.agg(np.mean)

对于多个分组而言，会产生层次索引的结果，如果希望层次索引成为单独一列的话，需要在groupby用到as_index选项。或者最后使用reset_index方法

# as_index

grouped = df.groupby(['A','B'], as_index=False)

grouped.agg(np.mean)

# reset_index

df.groupby(['A','B']).sum().reset_index()

aggregate或等价的agg还允许对每一列使用多个统计函数

df.groupby('A').agg([np.sum,np.mean,np.std])

# 语法糖 df.groupby('A').C 等价于

# grouped=df.groupby(['A'])

# grouped['C']

df.groupby('A').C.agg([np.sum,np.mean,np.std])

或者是不同列使用不同函数，比如说对D列计算标准差，对列求平均

grouped=df.groupby(['A'])

grouped.agg({'D': np.std , 'C': np.mean})

注：目前sum, mean, std和sem方法对Cython进行了优化。

转换: Transformation

transform返回的对象和原来分组数据具有相同的大小。转换所用的函数必须满足如下条件：

返回的结果大小要与原先的组块（group chunk)一致

在组块中逐列操作

并非在组块上原位运算。原先的组块被认为是不可修改的，任何对原来组块的修改可能会导致意想不到的结果。如果你用到了fillna，必须是grouped.transform(lambda x: x.fillna(inplace=False))

举例说明，比如说我们相对每一组数据进行标准化。当然我们先得有一组数据, 随机生成一组从1999年到2002年，然后以100天为一个滑窗(window)，计算每一个滑窗的均值（rolling)。

# date_range产生日期索引

index = pd.date_range('10/1/1999', periods=1100)

ts = pd.Series(np.random.normal(0.5, 2, 1100), index)

ts = ts.rolling(window=100,min_periods=100).mean().dropna()

然后要根据年份进行分组，对各组中的数据进行标准化，计算zscore.

# 两个匿名函数，用于分组和计算zscore

key = lambda x : x.year

zscore = lambda x : (x - x.mean())/x.std()

transformed = ts.groupby(key).transform(zscore)

应用zscore的过程中使用了广播（broadcast）技术。让我们可视化一下转换前后数据形状

compare = pd.DataFrame({'Original': ts, 'Transformed': transformed})

compare.plot()

转换前后

过滤：Filtration

过滤返回原先数据的子集。比如说上面时间周期数据，过滤掉均值小于0.55的年份。

ts.groupby(key).filter(lambda x : x.mean() > 0.55)

Apply: 更加灵活的“拆分-应用-合并”

上述的aggregate和transform都有一定的局限性，传入的函数只能有两个结果，要么是产生一个可以广播的标量值，要么是产生相同大小的数组。apply是一个更加一般化的函数，能完成上面所描述的所有任务，还能做得更好。

分组返回描述性统计结果

df.groupby('A').apply(lambda x : x.describe())

# 效果等价于df.groupby('A').describe()

apply

修改返回的分组名

def f(group):

return pd.DataFrame({'original' : group,

'demeaned' : group - group.mean()})

df.groupby('A')['C'].apply(f)

demeaned original

first second

bar one 0.278558 0.709603

two 0.280707 -0.140075

baz one 1.064283 1.495328

two -0.848109 -1.268891

foo one 0.064243 0.495288

two 0.567402 0.146620

qux one 1.218089 1.649135

two -2.625172 -2.194127

更多有用的技巧如获取每一组的第n行，见官方文档