數據分析之Pandas分組操作總結

↑↑↑關注後"星標"Datawhale

每日干貨 & 每月組隊學習，不錯過

Datawhale乾貨

作者：耿遠昊，Datawhale成員

Pandas做分析數據，可以分爲索引、分組、變形及合併四種操作。之前介紹過索引操作，現在接着對Pandas中的分組操作進行介紹：主要包含SAC含義、groupby函數、聚合、過濾和變換、apply函數。文章的最後，根據今天的知識介紹，給出了6個問題與2個練習，供大家學習實踐。

在詳細講解每個模塊之前，首先讀入數據：

import numpy as np
import pandas as pd
df = pd.read_csv('data/table.csv',index_col='ID')
df.head()

SAC過程

1. 內涵

SAC指的是分組操作中的split-apply-combine過程。其中split指基於某一些規則，將數據拆成若干組；apply是指對每一組獨立地使用函數；combine指將每一組的結果組合成某一類數據結構。

2. apply過程

在apply過程中，我們實際往往會遇到四類問題：

整合(Aggregation)：即分組計算統計量（如求均值、求每組元素個數）；
變換(Transformation)：即分組對每個單元的數據進行操作（如元素標準化）；
過濾(Filtration)：即按照某些規則篩選出一些組（如選出組內某一指標小於50的組）；
綜合問題：即前面提及的三種問題的混合。

groupby函數

經過groupby後會生成一個groupby對象，該對象本身不會返回任何內容，只有當相應的方法被調用纔會起作用。

1. 分組函數的基本內容：

根據某一列分組
根據某幾列分組
組容量與組數
組的遍歷
level參數(用於多級索引)和axis參數

a). 根據某一列分組

grouped_single = df.groupby('School')

經過groupby後會生成一個groupby對象，該對象本身不會返回任何東西，只有當相應的方法被調用纔會起作用。例如取出某一個組：

grouped_single.get_group('S_1').head()

b). 根據某幾列分組

grouped_mul = df.groupby(['School','Class'])
grouped_mul.get_group(('S_2','C_4'))

c). 組容量與組數

調用的時候最好先根據size看下里面的內容，不然在get_group的時候可能會出錯。

grouped_single.size()

grouped_mul.size()

grouped_single.ngroups
grouped_mul.ngroups

d). 組的遍歷

for name,group in grouped_single:
    print(name)
    display(group.head())

e). level參數（用於多級索引）和axis參數

df.set_index(['Gender','School']).groupby(level=1,axis=0).get_group('S_1').head()

2. groupby對象的特點：

查看所有可調用的方法
分組對象的head 和first
分組依據
groupby的[]操作
連續型變量分組

a). 查看所有可調用的方法

由此可見，groupby對象可以使用相當多的函數，靈活程度很高

print([attr for attr in dir(grouped_single) if not attr.startswith('_')])

b). 分組對象的head和first

對分組對象使用head函數，返回的是每個組的前幾行，而不是數據集前幾行

grouped_single.head(2)

first顯示的是以分組爲索引的每組的第一個分組信息

grouped_single.first()

c). 分組依據

對於groupby函數而言，分組的依據是非常自由的，只要是與數據框長度相同的列表即可，同時支持函數型分組。

df.groupby(np.random.choice(['a','b','c'],df.shape[0])).get_group('a').head()
# 相當於將np.random.choice(['a','b','c'],df.shape[0])當做新的一列進行分組

從原理上說，我們可以看到利用函數時，傳入的對象就是索引，因此根據這一特性可以做一些複雜的操作。

df[:5].groupby(lambda x:print(x)).head(0)

根據奇偶行分組。

df.groupby(lambda x:'奇數行' if not df.index.get_loc(x)%2==1 else '偶數行').groups

如果是多層索引，那麼lambda表達式中的輸入就是元組，下面實現的功能爲查看兩所學校中男女生分別均分是否及格。注意：此處只是演示groupby的用法，實際操作不會這樣寫。

math_score = df.set_index(['Gender','School'])['Math'].sort_index()
grouped_score = df.set_index(['Gender','School']).sort_index().\
            groupby(lambda x:(x,'均分及格' if math_score[x].mean()>=60 else '均分不及格'))
for name,_ in grouped_score:print(name)

d). groupby的[]操作

可以用[]選出groupby對象的某個或者某幾個列，上面的均分比較可以如下簡潔地寫出：

df.groupby(['Gender','School'])['Math'].mean()>=60

用列表可選出多個屬性列：

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

e). 連續型變量分組

例如利用cut函數對數學成績分組：

bins = [0,40,60,80,90,100]
cuts = pd.cut(df['Math'],bins=bins) #可選label添加自定義標籤
df.groupby(cuts)['Math'].count()

聚合、過濾和變換

1. 聚合

常用聚合函數
同時使用多個聚合函數
使用自定義函數
利用NameAgg函數
帶參數的聚合函數

a). 常用聚合函數

所謂聚合就是把一堆數，變成一個標量，因此mean/sum/size/count/std/var/sem/describe/first/last/nth/min/max都是聚合函數。爲了熟悉操作，不妨驗證標準誤sem函數，它的計算公式是：組內標準差/組容量，下面進行驗證：

group_m = grouped_single['Math']
group_m.std().values/np.sqrt(group_m.count().values)== group_m.sem().values

b). 同時使用多個聚合函數

group_m.agg(['sum','mean','std'])

利用元組進行重命名

group_m.agg([('rename_sum','sum'),('rename_mean','mean')])

指定哪些函數作用哪些列

grouped_mul.agg({'Math':['mean','max'],'Height':'var'})

c). 使用自定義函數

grouped_single['Math'].agg(lambda x:print(x.head(),'間隔'))
#可以發現，agg函數的傳入是分組逐列進行的，有了這個特性就可以做許多事情

官方沒有提供極差計算的函數，但通過agg可以容易地實現組內極差計算

grouped_single['Math'].agg(lambda x:x.max()-x.min())

d). 利用NamedAgg函數進行多個聚合

注意：不支持lambda函數，但是可以使用外置的def函數

def R1(x):
    return x.max()-x.min()
def R2(x):
    return x.max()-x.median()
grouped_single['Math'].agg(min_score1=pd.NamedAgg(column='col1', aggfunc=R1),
                           max_score1=pd.NamedAgg(column='col2', aggfunc='max'),
                           range_score2=pd.NamedAgg(column='col3', aggfunc=R2)).head()

e). 帶參數的聚合函數

判斷是否組內數學分數至少有一個值在50-52之間：

def f(s,low,high):
    return s.between(low,high).max()
grouped_single['Math'].agg(f,50,52)

如果需要使用多個函數，並且其中至少有一個帶參數，則使用wrap技巧：

def f_test(s,low,high):
    return s.between(low,high).max()
def agg_f(f_mul,name,*args,**kwargs):
    def wrapper(x):
        return f_mul(x,*args,**kwargs)
    wrapper.__name__ = name
    return wrapper
new_f = agg_f(f_test,'at_least_one_in_50_52',50,52)
grouped_single['Math'].agg([new_f,'mean']).head()

2. 過濾 Filteration
filter函數是用來篩選某些組的（務必記住結果是組的全體），因此傳入的值應當是布爾標量。

grouped_single[['Math','Physics']].filter(lambda x:(x['Math']>32).all()).head()

3. 變換 Transformation

傳入對象
利用變換方法進行組內標準化
利用變換方法進行組內缺失值的均值填充

a). 傳入對象

transform函數中傳入的對象是組內的列，並且返回值需要與列長完全一致

grouped_single[['Math','Height']].transform(lambda x:x-x.min()).head()

如果返回了標量值，那麼組內的所有元素會被廣播爲這個值

grouped_single[['Math','Height']].transform(lambda x:x.mean()).head()

b). 利用變換方法進行組內標準化

grouped_single[['Math','Height']].transform(lambda x:(x-x.mean())/x.std()).head()

c). 利用變換方法進行組內缺失值的均值填充

df_nan = df[['Math','School']].copy().reset_index()
df_nan.loc[np.random.randint(0,df.shape[0],25),['Math']]=np.nan
df_nan.head()

df_nan.groupby('School').transform(lambda x: x.fillna(x.mean())).join(df.reset_index()['School']).head()

apply函數

1. apply函數的靈活性

標量返回值
列表返回值
數據框返回值

可能在所有的分組函數中，apply是應用最爲廣泛的，這得益於它的靈活性：對於傳入值而言，從下面的打印內容可以看到是以分組的表傳入apply中。

df.groupby('School').apply(lambda x:print(x.head(1)))

apply函數的靈活性很大程度來源於其返回值的多樣性：

a). 標量返回值

df[['School','Math','Height']].groupby('School').apply(lambda x:x.max())

b). 列表返回值

df[['School','Math','Height']].groupby('School').apply(lambda x:x-x.min()).head()

c). 數據框返回值

df[['School','Math','Height']].groupby('School')\
    .apply(lambda x:pd.DataFrame({'col1':x['Math']-x['Math'].max(),
                                  'col2':x['Math']-x['Math'].min(),
                                  'col3':x['Height']-x['Height'].max(),
                                  'col4':x['Height']-x['Height'].min()})).head()

2. 用apply同時統計多個指標

此處可以藉助OrderedDict工具進行快捷的統計：

from collections import OrderedDict
def f(df):
    data = OrderedDict()
    data['M_sum'] = df['Math'].sum()
    data['W_var'] = df['Weight'].var()
    data['H_mean'] = df['Height'].mean()
    return pd.Series(data)
grouped_single.apply(f)

問題與練習

問題

問題1. 什麼是fillna的前向/後向填充，如何實現？

import numpy as np
import pandas as pd
df = pd.read_csv('data/table.csv',index_col='ID')
df.head(3)

df_nan = df[['Math','School']].copy().reset_index()
df_nan.loc[np.random.randint(0,df.shape[0],25),['Math']]=np.nan
df_nan.head()

fillna 的method方法可以控制參數的填充方式，是向上填充：將缺失值填充爲該列中它上一個未缺失值；向下填充相反
method : {‘backfill', ‘bfill', ‘pad', ‘ffill', None}, default None
pad / ffill: 向下自動填充
backfill / bfill: 向上自動填充

df_nan.Math=df_nan.Math.fillna(method='pad')
df_nan.head()

問題2. 下面的代碼實現了什麼功能？請仿照設計一個它的groupby版本。

s = pd.Series ([0, 1, 1, 0, 1, 1, 1, 0])
s1 = s.cumsum()
result = s.mul(s1).diff().where(lambda x: x < 0).ffill().add(s1,fill_value =0)

s1：將s序列求累加和 [0, 1, 2, 2, 3, 4, 5, 5]
s.mul(s1)：s 與s1累乘 [0, 1, 2, 0, 3, 4, 5, 0]
.diff() 求一階差分 [nan, 1.0, 1.0, -2.0, 3.0, 1.0, 1.0, -5.0]
.where(lambda x: x < 0) 值是否小於0：[nan, nan, nan, -2.0, nan, nan, nan, -5.0]
.ffill()：向下填充 [nan, nan, nan, -2.0, -2.0, -2.0, -2.0, -5.0]
.add(s1,fill_value =0) 缺失值補0後與s1求和：[0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 3.0, 0.0]

list(s.mul(s1).diff().where(lambda x: x < 0).ffill().add(s1,fill_value =0))


gp =df.groupby('School')
gp.apply(lambda x:x['Math'].mul(x['Math'].cumsum()).diff().where(lambda m: m < 0).ffill().add(x['Math'].cumsum(),fill_value =0)

問題3. 如何計算組內0.25分位數與0.75分位數？要求顯示在同一張表上。

gp.apply(lambda x:pd.DataFrame({'q25':x.quantile(0.25),
                                  'q75':x.quantile(0.75)
                                       }))

問題4. 既然索引已經能夠選出某些符合條件的子集，那麼filter函數的設計有什麼意義？

答：filter函數是用來篩選組的，結果是組的全體。

問題5. 整合、變換、過濾三者在輸入輸出和功能上有何異同？

整合（Aggregation）分組計算統計量：輸入的是每組數據，輸出是每組的統計量，在列維度上是標量。
變換（Transformation）：即分組對每個單元的數據進行操作（如元素標準化）：輸入的是每組數據，輸出是每組數據經過某種規則變換後的數據,不改變數據的維度。
過濾（Filtration）：即按照某些規則篩選出一些組:輸入的是每組數據，輸出的是滿足要求的組的所有數據。

問題6. 在帶參數的多函數聚合時，有辦法能夠繞過wrap技巧實現同樣功能嗎？

def f_test(s,low=50,high=52):
    return s.between(low,high).max()
grouped_single['Math'].agg([f_test,'mean']).head()
#這裏需要理解的是，agg除了傳入字符形式的np函數外，其他傳入對象也應當是一個函數

練習

練習1 ：現有一份關於diamonds的數據集，列分別記錄了克拉數、顏色、開採深度、價格，請解決下列問題：

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

(a). 在所有重量超過1克拉的鑽石中，價格的極差是多少？

df.groupby(lambda x : '>1克拉' if df.loc[x,'carat']>1.0 else '<=1克拉').price.agg(lambda x:x.max()-x.min()

(b). 若以開採深度的0.2\0.4\0.6\0.8分位數爲分組依據，每一組中鑽石顏色最多的是哪一種？該種顏色是組內平均而言單位重量最貴的嗎？

bins=[df.depth.quantile(i) for i in [0,0.2,0.4,0.6,0.8,1]]
df['cuts']=pd.cut(df.depth,bins=bins)
df['unit_price']=df['price']/df['carat']df.groupby(['cuts','color'])['unit_price'].agg(['count','mean']).reset_index().groupby('cuts')\
    .apply(lambda x:pd.DataFrame({'cuts':x['cuts'],'color':x['color']
                                  ,'count':x['count'],'count_diff':x['count']-x['count'].max()
                                  , 'mean':x['mean'], 'mean_diff':x['mean']-x['mean'].max()})).sort_values(by='count_diff',ascending=False)
##有些是單位質量最貴的，有些不是(當count_diff與mean_diff同爲0時，則是)

(c). 以重量分組(0-0.5,0.5-1,1-1.5,1.5-2,2+)，按遞增的深度爲索引排序，求每組中連續的嚴格遞增價格序列長度的最大值。

bins=[0,0.5,1,1.5,2,6]
df['carat_cuts']=pd.cut(df.carat,bins=bins)
sorted_df=df.groupby('carat_cuts').apply(lambda x:x.sort_values('depth')).reset_index(drop=True)
#再求價格遞增
tp=sorted_df.groupby('carat_cuts').apply(lambda x: pd.DataFrame({'carat_cuts':x['carat_cuts'],'price':x['price'],'is_f':x['price'].diff()>0,'continuous':((x['price'].diff()>0)!=(x['price'].diff()>0).shift()).cumsum()} ))
tp.loc[tp.is_f==True,:].groupby(['carat_cuts','continuous']).price.agg(['count']).reset_index().groupby('carat_cuts').max()


##因爲沒有計算序列第一個值。嚴格遞增最大序列長度在max的基礎上+1，結果如下.
#(0.0, 0.5]  8
#(0.5, 1.0]  8
#(1.0, 1.5]  7
#(1.5, 2.0]  11
#(2.0, 6.0]  7

(d). 請按顏色分組，分別計算價格關於克拉數的迴歸係數。（單變量的簡單線性迴歸，並只使用Pandas和Numpy完成）

df['ones']=1
colors=['G','E','F','H','D','I','J']
for  c in colors:
    X=np.matrix( df.loc[ df.color==c, ['carat','ones']].values)
    Y=np.matrix( df.loc[ df.color==c, ['price']].values)
                    
    params=np.linalg.inv(X.T@X)@X.T@Y
    
    print('color {}的 參數爲k={},b={}'.format(c,params[0],params[1]) )


# color G的 參數爲k=[[8525.34577932]],b=[[-2575.52764286]]
# color E的 參數爲k=[[8296.21278346]],b=[[-2381.04960038]]
# color F的 參數爲k=[[8676.65834379]],b=[[-2665.80619085]]
# color H的 參數爲k=[[7619.0983199]],b=[[-2460.41804636]]
# color D的 參數爲k=[[8408.35312588]],b=[[-2361.01715228]]
# color I的 參數爲k=[[7761.04116881]],b=[[-2878.15035558]]
# color J的 參數爲k=[[7094.19209226]],b=[[-2920.60333719]]

練習2：有一份關於美國10年至17年的非法藥物數據集，列分別記錄了年份、州（5個）、縣、藥物類型、報告數量，請解決下列問題：

pd.read_csv('data/Drugs.csv').head()

(a). 按照年份統計，哪個縣在哪年的報告數量最多？這個縣所屬的州在當年也是報告數最多的嗎？

答：按照年份統計，HAMILTON在2017年報告數量最多，該縣所屬的州PA在當年不是報告數最多的。

df_ex2.groupby(['YYYY', 'COUNTY'])['DrugReports'].sum().sort_values(ascending = False

df_ex2['State'][df_ex2['COUNTY'] == 'HAMILTON'].unique()
array(['PA'], dtype=object)
df_ex2.loc[df_ex2['YYYY'] == 2017, :].groupby('State')['DrugReports'].sum().sort_values(ascending = False)

(b). 從14年到15年，Heroin的數量增加最多的是哪一個州？它在這個州是所有藥物中增幅最大的嗎？若不是，請找出符合該條件的藥物。

答：從14年到15年，Heroin的數量增加最多的是OH，它在這個州是所有藥物中增幅最大。

方法一

df_ex2_b_1 = df_ex2.loc[((df_ex2['YYYY'] == 2014) | (df_ex2['YYYY'] == 2015)) & (df_ex2['SubstanceName'] == 'Heroin'), :]
df_ex2_b_2 = df_ex2_b_1.groupby(['YYYY', 'State'])['DrugReports'].sum().to_frame().unstack(level=0)
(df_ex2_b_2[('DrugReports', 2015)] - df_ex2_b_2[('DrugReports', 2014)]).sort_values(ascending = False)

方法二

df_ex2_b_1 = df_ex2.loc[((df_ex2['YYYY'] == 2014) | (df_ex2['YYYY'] == 2015)) & (df_ex2['SubstanceName'] == 'Heroin'), :]
df_ex2_b_3 = df_ex2_b_1.groupby(['YYYY', 'State'])['DrugReports'].sum().to_frame()
df_ex2_b_3.groupby('State').apply(lambda x:x.loc[2015, :] - x.loc[2014, :]).sort_values(by = 'DrugReports', ascending = False)

df_ex2_b_1 = df_ex2.loc[((df_ex2['YYYY'] == 2014) | (df_ex2['YYYY'] == 2015)), :]
df_ex2_b_2 = df_ex2_b_1.groupby(['YYYY', 'State', 'SubstanceName'])['DrugReports'].sum().to_frame().unstack(level=0)
(df_ex2_b_2[('DrugReports', 2015)] - df_ex2_b_2[('DrugReports', 2014)]).sort_values(ascending = False)

本文電子版 後臺回覆 Pandas分組 獲取

“在看，爲沉迷學習點贊↓