pandas task04

一、透视表

1.pivot
一般状态下，数据在DataFrame会以压缩（stacked）状态存放，例如上面的Gender，两个类别被叠在一列中，pivot函数可将某一列作为新的cols：

import numpy as np
import pandas as pd
df = pd.read_csv('datalab/61658/table.csv')
df.head()

df.pivot(index='ID',columns='Gender',values='Height').head()

#然而pivot函数具有很强的局限性，除了功能上较少之外，还不允许values中出现重复的行列索引对（pair），例如下面的语句就会报错：
#df.pivot(index='School',columns='Gender',values='Height').head()
#因此，更多的时候会选择使用强大的pivot_table函数

2.pivot_table

#2. pivot_table
#首先，再现上面的操作：
pd.pivot_table(df,index='ID',columns='Gender',values='Height').head()

#由于功能更多，速度上自然是比不上原来的pivot函数：
%timeit df.pivot(index='ID',columns='Gender',values='Height')
%timeit pd.pivot_table(df,index='ID',columns='Gender',values='Height')

#Pandas中提供了各种选项，下面介绍常用参数：
#① aggfunc：对组内进行聚合统计，可传入各类函数，默认为'mean'
pd.pivot_table(df,index='School',columns='Gender',values='Height',aggfunc=['mean','sum']).head()

#② margins：汇总边际状态
pd.pivot_table(df,index='School',columns='Gender',values='Height',aggfunc=['mean','sum'],margins=True).head()
#margins_name可以设置名字，默认为'All'

#③ 行、列、值都可以为多级
pd.pivot_table(df,index=['School','Class'],
               columns=['Gender','Address'],
               values=['Height','Weight'])

3.crosstab（交叉表）

#3. crosstab（交叉表）
#交叉表是一种特殊的透视表，典型的用途如分组统计，如现在想要统计关于街道和性别分组的频数：
pd.crosstab(index=df['Address'],columns=df['Gender'])

#交叉表的功能也很强大（但目前还不支持多级分组），下面说明一些重要参数：
#① values和aggfunc：分组对某些数据进行聚合操作，这两个参数必须成对出现
pd.crosstab(index=df['Address'],columns=df['Gender'],
            values=np.random.randint(1,20,df.shape[0]),aggfunc='min')
#默认参数等于如下方法：
#pd.crosstab(index=df['Address'],columns=df['Gender'],values=1,aggfunc='count')

#② 除了边际参数margins外，还引入了normalize参数，可选'all','index','columns'参数值
pd.crosstab(index=df['Address'],columns=df['Gender'],normalize='all',margins=True)

二、其它变形方法

1.melt

#1. melt
#melt函数可以认为是pivot函数的逆操作，将unstacked状态的数据，压缩成stacked，使“宽”的DataFrame变“窄”
df_m = df[['ID','Gender','Math']]
df_m.head()

df.pivot(index='ID',columns='Gender',values='Math').head()

#melt函数中的id_vars表示需要保留的列，value_vars表示需要stack的一组列
pivoted = df.pivot(index='ID',columns='Gender',values='Math')
result = pivoted.reset_index().melt(id_vars=['ID'],value_vars=['F','M'],value_name='Math')\
                     .dropna().set_index('ID').sort_index()
#检验是否与展开前的df相同，可以分别将这些链式方法的中间步骤展开，看看是什么结果
result.equals(df_m.set_index('ID'))

2.压缩与展开

#2. 压缩与展开
#（1）stack：这是最基础的变形函数，总共只有两个参数：level和dropna
df_s = pd.pivot_table(df,index=['Class','ID'],columns='Gender',values=['Height','Weight'])
df_s.groupby('Class').head(2)

df_stacked = df_s.stack()
df_stacked.groupby('Class').head(2)

#stack函数可以看做将横向的索引放到纵向，因此功能类似与melt，参数level可指定变化的列索引是哪一层（或哪几层，需要列表）
df_stacked = df_s.stack(0)
df_stacked.groupby('Class').head(2)

#(2) unstack：stack的逆函数，功能上类似于pivot_table
df_stacked.head()

result = df_stacked.unstack().swaplevel(1,0,axis=1).sort_index(axis=1)
result.equals(df_s)
#同样在unstack中可以指定level参数

三、哑变量与因子化

1.Dummy Variable（哑变量）

#1. Dummy Variable（哑变量）
#这里主要介绍get_dummies函数，其功能主要是进行one-hot编码：
df_d = df[['Class','Gender','Weight']]
df_d.head()

#现在希望将上面的表格前两列转化为哑变量，并加入第三列Weight数值：
pd.get_dummies(df_d[['Class','Gender']]).join(df_d['Weight']).head()
#可选prefix参数添加前缀，prefix_sep添加分隔符

2.factorize方法

#2. factorize方法
#该方法主要用于自然数编码，并且缺失值会被记做-1，其中sort参数表示是否排序后赋值
codes, uniques = pd.factorize(['b', None, 'a', 'c', 'b'], sort=True)
display(codes)
display(uniques)

四、问题与练习

1.问题
【问题一】 上面提到了许多变形函数，如melt/crosstab/pivot/pivot_table/stack/unstack函数，请总结它们各自的使用特点。
melt：压缩DataFrame，合并某些数据；
crosstab：分组统计；
pivot：展开DataFrame，拆开某些项作为新列；
pivot_table：基本功能同pivot，但功能更丰富；
stack：展开数据；
unstack：合并数据。

pivot函数
不能分组，index和columns不能完全相同，否则会报错
pivot_table函数
（1）有分组功能，可以通过aggfunc参数对组内数据进行聚合统计，可传入各类函数，默认为mean
（2）可以通过margins参数汇总边际状态，通过margins_name设置名字
（3）行，列，值都可以为多级
crosstab函数
支持分组，但不支持多级分组，可以通过normalize参数进行数据归一化，也可以汇总边际状态
melt函数
相当于pivot函数的逆操作
stack函数
可以将通过pivot_table函数压缩的数据展开成stack,参数level可指定变化的列索引是哪一层
unstack函数
stack的逆函数，功能上类似于pivot_table()函数

【问题二】 变形函数和多级索引是什么关系？哪些变形函数会使得索引维数变化？具体如何变化？
变形函数有些类似多级索引的形式，都是将某个大项中相同的值提出，然后作为新的索引。变形函数一般在列索引上操作，多级索引可以是行多级索引，也可以是列多级索引。
pivot和pivot_table：使列索引维数变化，增加的维数为colums参数的类别数减一。
melt：除了列数减少，行数增加为stack前各值的穷举，用NAN填充。

可以通过设置变形函数的index，values参数来生成多级索引

【问题三】 请举出一个除了上文提过的关于哑变量方法的例子。

df['count']=1
df_s = pd.pivot_table(df,index=['Class','ID'],columns='Gender',values=['count'])
df_s.stack(0).unstack(0).replace(np.nan,0).head()

【问题四】 使用完stack后立即使用unstack一定能保证变化结果与原始表完全一致吗？

df_s = pd.pivot_table(df,index=['Class','ID'],columns='Gender',values=['Height','Weight'])

df_s.stack().unstack().equals(df_stacked)  # False

【问题五】 透视表中涉及了三个函数，请分别使用它们完成相同的目标（任务自定）并比较哪个速度最快。

%timeit df.pivot(index='ID',columns='Gender',values='Height')
%timeit pd.pivot_table(df,index='ID',columns='Gender',values = "Height")
%timeit pd.crosstab(index=df['ID'],columns=df['Gender'])

【问题六】 既然melt起到了stack的功能，为什么再设计stack函数？
stack()只有level和dropna两个参数，只能进行简单的stack功能；而melt则提供了id_vars、value_vars和value_name来将一些index旋转到columns，功能上更加灵活和高级。
stack函数的参数level可指定变化的列索引是哪一层

2.练习
【练习一】 继续使用上一章的药物数据集：pd.read_csv(‘data/Drugs.csv’).head()

#(a)
df = pd.read_csv('datalab/61658/Drugs.csv',index_col=['State','COUNTY']).sort_index()
df.head()

result = pd.pivot_table(df,index=['State','COUNTY','SubstanceName'],columns='YYYY',values='DrugReports',fill_value='-').reset_index().rename(columns={'YYYY':''})
result.head()

#(b)
result_melted = result.melt(id_vars=result.columns[:3],value_vars=result.columns[-8:]
                ,var_name='YYYY',value_name='DrugReports').query('DrugReports != "-"')
result2 = result_melted.sort_values(by=['State','COUNTY','YYYY'
                                    ,'SubstanceName']).reset_index().drop(columns='index')
#下面其实无关紧要，只是交换两个列再改一下类型（因为‘-’所以type变成object了）
cols = list(result2.columns)
a, b = cols.index('SubstanceName'), cols.index('YYYY')
cols[b], cols[a] = cols[a], cols[b]
result2 = result2[cols].astype({'DrugReports':'int','YYYY':'int'})
result2.head()

df_tidy = df.reset_index().sort_values(by=result2.columns[:4].tolist()).reset_index().drop(columns='index')
df_tidy.head()

df_tidy.equals(result2)

【练习二】 现有一份关于某地区地震情况的数据集，请解决如下问题：pd.read_csv(‘data/Earthquake.csv’).head()

#(a)
df = pd.read_csv('datalab/61658/Earthquake.csv')
df = df.sort_values(by=df.columns.tolist()[:3]).sort_index(axis=1).reset_index().drop(columns='index')
df.head()

result = pd.pivot_table(df,index=['日期','时间','维度','经度']
            ,columns='方向'
            ,values=['烈度','深度','距离'],fill_value='-').stack(level=0).rename(index={None:'地震参数'})
result.head(6)

(b)
df_result = result.unstack().stack(0)[(~(result.unstack().stack(0)=='-')).any(1)].reset_index()
df_result.columns.name=None
df_result = df_result.sort_index(axis=1).astype({'深度':'float64','烈度':'float64','距离':'float64'})
df_result.head()

df_result.astype({'深度':'float64','烈度':'float64','距离':'float64'},copy=False).dtypes

df.equals(df_result)