task_5变形

一、作业

# 作业1
df = pd.read_csv('data/drugs.csv').sort_values([     'State','COUNTY','SubstanceName'],ignore_index=True)
df.head()
#将第1问中的结果恢复为原表。
df3 = df2.melt(id_vars=['State', 'COUNTY', 'SubstanceName'],
               value_vars=[2010,2011,2012,2013,2014,2015,2016,2017],
               var_name='YYYY',
               value_name='DrugReports'
              )


#按 State 分别统计每年的报告数量总和，其中 State, YYYY 分别为列索引和行索引，
#要求分别使用 pivot_table 函数与 groupby+unstack 两种不同的策略实现，并体会它们之间的联系。
# pivot_table 函数
df4 = df.pivot_table(index = ['State'],
                       columns = ['YYYY'],
                       values = 'DrugReports',
                    aggfunc='sum', margins=True)
df4

#groupby+unstack
df5 = df.groupby(['State','YYYY'])['DrugReports']
df5.sum().unstack()

二、长宽表的变形

长表、宽表是对于某一个特征而言的。例如：一个表中把性别存储在某一个列中，那么它就是关于性别的长表；如果把性别作为列名，列中的元素是某一其他的相关特征数值，那么这个表是关于性别的宽表。

pd.DataFrame({'Gender':['F','F','M','M'],'Height':[167,159,173,178]})
pd.DataFrame({'Height:F':[167,159],'Height:M':[173,178]})

2.1 pivot

pivot 是一种典型的长表变宽表的函数，

df = pd.DataFrame({'Class':[1,1,2,2],
                   'Name':['San Zhang','San Zhang','Si Li','Si Li'],
                   'Subject':['Chinese','Math','Chinese','Math'],
                   'Grade':[80,75,90,85]})
df

变形后的行索引、需要转到列索引的列，以及这些列和行索引对应的数值，它们分别对应了 pivot 方法中的 index, columns, values 参数

df.pivot(index='Name',columns='Subject',values='Grade')
df.pivot(index='Subject',columns='Class',values='Grade')

利用 pivot 进行变形操作需要满足唯一性的要求，即由于在新表中的行列索引对应了唯一的 value ，因此原表中的 index 和 columns 对应两个列的行组合必须唯一。

df1=pd.DataFrame({'Class':[1, 1, 2, 2, 1, 1, 2, 2],
                   'Name':['San Zhang', 'San Zhang', 'Si Li', 'Si Li',
                            'San Zhang', 'San Zhang', 'Si Li', 'Si Li'],
                  'Examination': ['Mid', 'Final', 'Mid', 'Final',
                                'Mid', 'Final', 'Mid', 'Final'],
                 'Subject':['Chinese', 'Chinese', 'Chinese', 'Chinese',
                              'Math', 'Math', 'Math', 'Math'],
                  'Grade':[80, 75, 85, 65, 90, 85, 92, 88],
                  'rank':[10, 15, 21, 15, 20, 7, 6, 2]})
pivot_multi = df1.pivot(index=['Class','Name'],columns=['Examination','Subject'],values=['Grade','rank'])

2.2 pivot_table

pivot 的使用依赖于唯一性条件，那如果不满足唯一性条件，那么必须通过聚合操作使得相同行列组合对应的多个值变为一个值。pandas 中提供了 pivot_table 来实现，其中的 aggfunc 参数就是使用的聚合函数。

df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang',
                           'San Zhang', 'San Zhang',
                            'Si Li', 'Si Li', 'Si Li', 'Si Li'],
                    'Subject':['Chinese', 'Chinese', 'Math', 'Math',
                              'Chinese', 'Chinese', 'Math', 'Math'],
                    'Grade':[80, 90, 100, 90, 70, 80, 85, 95]})
df2
df2.pivot_table(index='Name',columns='Subject',values='Grade',aggfunc='mean')
#Subject	Chinese	Math
#Name		
#San Zhang	85	95
#Si Li	75	90

这里传入 aggfunc 包含了上一章中介绍的所有合法聚合字符串，此外还可以传入以序列为输入标量为输出的聚合函数来实现自定义操作，

df2.pivot_table(index='Name',columns='Subject',values='Grade',aggfunc=lambda x: x.mean())

pivot_table具有边际汇总的功能，可以通过设置margins=True来实现，其中边际的聚合方式与aggfunc中给出的聚合方法一致。

df2.pivot_table(index='Name',columns='Subject',values='Grade',aggfunc='mean',margins=True)

• 注：每行All的值不是一行的均值，而是那一行原表的均值。！！!
• 练一练,在上面的边际汇总例子中，行或列的汇总为新表中行元素或者列元素的平均值，而总体的汇总为新表中四个元素的平均值。这种关系一定成立吗？若不成立，请给出一个例子来说明。
  答：当表中存在缺失值时，结果会不一致，例如

df_ex = pd.DataFrame({'Name':['San Zhang', 
                           'San Zhang', 'San Zhang',
                            'Si Li', 'Si Li'],
                  'Subject':['Chinese', 'Chinese','IT',
                               'Chinese', 'Chinese'],
                   'Grade':[80, 90, 100, 90, 90]})
df_ex
df_ex.pivot_table(index='Name',columns='Subject',values='Grade',aggfunc='mean',margins=True)
#Subject	Chinese	IT	All
#Name			
#San Zhang	85.0	100.0	90
#Si Li	90.0	NaN	90
#All	87.5	100.0	90

2.3 melt

长宽表只是数据呈现方式的差异，但其包含的信息量是等价的，前面提到了利用 pivot 把长表转为宽表，那么就可以通过相应的逆操作把宽表转为长表， melt 函数就起到了这样的作用。
在下面的例子中， Subject 以列索引的形式存储，现在想要将其压缩到一个列中。

df3 = pd.DataFrame({'Class':[1,2],'Name':['San Zhang','Si Li'],'Chinese':[80,90],'Math':[85,95]})
df3
df3_melted = df3.melt(id_vars=['Class','Name'],value_vars=['Chinese','Math'],var_name='Subject',value_name='Grade')

• id_vars是每一个列变量类别会对应一个id_vars的块，个人理解是指原来表中不变的列
• value_vars是需要从原来列变为行中的变量，这里是把列名变为表中元素值了。
• var_name是原来列变量名的含义，也就是现表中改变的列名
• value_name是原来列变量值的含义，
• 新表与原表相比：行数变为：原行数*改变的列数，列数为原表中不变的列加2列(即var_name和value_name两列)
  具体过程如下图所示
  
  前面提到了 melt 和 pivot 是一组互逆过程，那么就一定可以通过 pivot 操作把 df_melted 转回 df 的形式：

df3_unmelted = df3_melted.pivot(index=['Class','Name'],columns='Subject',values='Grade')
df3_unmelted#先 恢复成了多级索引
df3_unmelted=df3_unmelted.reset_index().rename_axis(columns={'Subject':''})
df3_unmelted#把多出的Subject变为空

2.4 wide_to_long

melt 方法中，在列索引中被压缩的一组值对应的列元素只能代表同一层次的含义，即 values_name 。现在如果列中包含了交叉类别，比如期中期末的类别和语文数学的类别，那么想要把 values_name 对应的 Grade 扩充为两列分别对应语文分数和数学分数，只把期中期末的信息压缩，这种需求下就要使用 wide_to_long 函数来完成。

df4 = pd.DataFrame({'Class':[1,2],'Name':['San Zhang', 'Si Li'],'Chinese_mid':[80, 75],
                   'Math_mid':[90, 85],'Chinese_final':[85, 80],'Math_final':[90, 80],})
df4
pd.wide_to_long(df4,
               stubnames=['Chinese','Math'],
               i=['Class','Name'],
               j='Examination',
               sep = '_',
                suffix='.+')

• stubnames为要改动列的变量值的含义，转化后的表以其为列，等价于melt中的value_name,
• i为保持不变的id变量，等价于melt的id_vars,
• j 为压缩到行的变量名含义，等价于melt中的var_name
• sep为分隔符
• suffix为正则后缀？？？
  具体过程如下图所示
  

res = pivot_multi.copy()
res.columns= res.columns.map(lambda x: '_'.join(x))
res = res.reset_index()
res
res = pd.wide_to_long(res,
                      stubnames=['Grade','rank'],
                      i = ['Class','Name'],
                      j = 'Subject_Examination',
                      sep = '_',
                      suffix = '.+')
res#将原来的列变为行
#下面是变回去
res= res.reset_index()
res[['Subject','Examination']]=res['Subject_Examination'].str.split("_",expand=True)
res = res[['Class', 'Name', 'Examination',
            'Subject', 'Grade', 'rank']].sort_values('Subject')
res= res.reset_index(drop=True)
res

三、索引的变形

3.1 stack与unstack

行列索引之间 的交换，由于这种交换带来了 DataFrame 维度上的变化，因此属于变形操作。在第一节中提到的4种变形函数与其不同之处在于，它们都属于某一列或几列 元素 和 列索引 之间的转换，而不是索引之间的转换。
unstack 函数的作用是把行索引转为列索引

df = pd.DataFrame(np.ones((4,2)),index=pd.Index([('A','cat','big'),('A','dog','small'),
                                                 ('B','cat','big'),('B','dog','small')]),
                 columns=['col_1','col_2'])
df
df.unstack()#把最里面的那层行索引转换为列索引

unstack 的主要参数是移动的层号，默认转化最内层，移动到列索引的最内层，同时支持同时转化多个层：

df.unstack(1)#转中间那层
df.unstack([0,2])#转最外层行为第二层列，第内层行为最内层列，
df.unstack([2,1])#先转前面位置的层也就是第三层，然后第2层到列的最内层

类似于pivot中的唯一性要求，在unstack中必须保证被转为列索引的行索引层和被保留的行索引层构成的组合是唯一的，

my_index = df.index.to_list()
my_index[1]=my_index[0]
df.index = pd.Index(my_index)
df
try:
    df.unstack()
except Exception as e:
        Err_Msg = e
Err_Msg #ValueError('Index contains duplicate entries, cannot reshape')

与 unstack 相反， stack 的作用就是把列索引的层压入行索引，其用法完全类似。

df1 = pd.DataFrame(np.ones((4,2)),index=pd.Index([('A','cat','big'),('A','dog','small'),
                                                 ('B','cat','big'),('B','dog','small')]),
                 columns=['index_1','index_2']).T
df1
df1.stack()#把列最内侧转为行最内层
df1.stack([2,0])

四、其他变形函数

crosstab

crosstab 并不是一个值得推荐使用的函数，因为它能实现的所有功能 pivot_table 都能完成，并且速度更快。在默认状态下， crosstab 可以统计元素组合出现的频数，即 count 操作。

df = pd.read_csv('../joyful-pandas-master/data/learn_pandas.csv')
pd.crosstab(index=df['School'],columns=df['Transfer'])
#等价于如下 crosstab 的如下写法，这里的 aggfunc 即聚合参数：
#pd.crosstab(index = df.School,columns=df.Transfer,aggfunc='count')#报错，少了values
pd.crosstab(index = df.School,columns=df.Transfer,values = [0]*df.shape[0],aggfunc='count')#为什么values要设置为0

同样，可以利用 pivot_table 进行等价操作，由于这里统计的是组合的频数，因此 values 参数无论传入哪一个列都不会影响最后的结果：

df.pivot_table(index = 'School',columns= 'Transfer',values = 'Grade',aggfunc='count')

crosstab 的对应位置传入的是具体的序列，而pivot_table传入的是被调用表对应的名字，若传入序列对应的值则会报错。除了默认状态下的 count 统计，所有的聚合字符串和返回标量的自定义函数都是可用的，

pd.crosstab(index = df.School, columns = df.Transfer,
             values = df.Height, aggfunc = 'mean')

explode

explode 参数能够对某一列的元素进行纵向的展开，被展开的单元格必须存储 list, tuple, Series, np.ndarray 中的一种类型。

df_ex = pd.DataFrame({'A':[[1,2],'my_str',{1,2},pd.Series([3,4])],'B':1})
df_ex
df_ex.explode('A')#[1,2]变为单个1，2，{1，2}未变，pd.Series([3,4])变为单独的3，4

get_dummies

get_dummies 是用于特征构建的重要函数之一，其作用是把类别特征转为指示变量。
例如，对性别一列转为指示变量，属于性别的对应列标记为1，否则为0：

pd.get_dummies(df.Gender).head()