第五章 pandas变形
import numpy as np
import pandas as pd
一、长宽表的变形
- 举例性别列，用一列存储为长表，用两列（男、女）分别存储为宽表
pandas针对此类长宽表的变形操作设计了一些有关的变形函数。- jupyter nbconvert --to markdown E:PycharmProjectsTianChiProject 0_山枫叶纷飞competitions 08_joyful-pandas 5_pandas变形.ipynb
# 长
pd.DataFrame({'Gender':['F','F','M','M'], 'Height':[163, 160, 175, 180]})
| Gender | Height | |
|---|---|---|
| 0 | F | 163 |
| 1 | F | 160 |
| 2 | M | 175 |
| 3 | M | 180 |
# 宽
pd.DataFrame({'Height: F':[163, 160], 'Height: M':[175, 180]})
| Height: F | Height: M | |
|---|---|---|
| 0 | 163 | 175 |
| 1 | 160 | 180 |
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
| Class | Name | Subject | Grade | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | Chinese | 80 |
| 1 | 1 | San Zhang | Math | 75 |
| 2 | 2 | Si Li | Chinese | 90 |
| 3 | 2 | Si Li | Math | 85 |
对于一个基本的长变宽的操作而言，最重要的有三个要素，分别是变形后的行索引、需要转到列索引的列，以及这些列和行索引对应的数值，它们分别对应了pivot方法中的index, columns, values参数。
- 新生成表的列索引是
columns对应列的unique值，而新表的行索引是index对应列的unique值，而values对应了想要展示的数值列。 - 确保行*列的所有组合情况中没有重复值，存在重复值会提示reshape异常，pivot无法进行绘制。
df.pivot(index='Name', columns='Subject', values='Grade')
| Subject | Chinese | Math |
|---|---|---|
| Name | ||
| San Zhang | 80 | 75 |
| Si Li | 90 | 85 |
# 尝试进行一次报错处理
df.loc[1, 'Subject'] = 'Chinese'
try:
df.pivot(index='Name', columns='Subject', values='Grade')
except Exception as e:
Err_Msg = e
Err_Msg
ValueError('Index contains duplicate entries, cannot reshape')
pandas从1.1.0开始，pivot相关的三个参数允许被设置为列表，这也意味着会返回多级索引。
这里构造一个相应的例子来说明如何使用：下表中六列分别为班级、姓名、测试类型（期中考试和期末考试）、科目、成绩、排名。
df = 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]})
df.head()
| Class | Name | Examination | Subject | Grade | rank | |
|---|---|---|---|---|---|---|
| 0 | 1 | San Zhang | Mid | Chinese | 80 | 10 |
| 1 | 1 | San Zhang | Final | Chinese | 75 | 15 |
| 2 | 2 | Si Li | Mid | Chinese | 85 | 21 |
| 3 | 2 | Si Li | Final | Chinese | 65 | 15 |
| 4 | 1 | San Zhang | Mid | Math | 90 | 20 |
# 现在想要把测试类型和科目联合组成的四个类别（期中语文、期末语文、期中数学、期末数学）转到列索引，并且同时统计成绩和排名：
pivot_multi = df.pivot(index = ['Class', 'Name'],
columns = ['Subject','Examination'],
values = ['Grade','rank'])
pivot_multi
| Grade | rank | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| Subject | Chinese | Math | Chinese | Math | |||||
| Examination | Mid | Final | Mid | Final | Mid | Final | Mid | Final | |
| Class | Name | ||||||||
| 1 | San Zhang | 80 | 75 | 90 | 85 | 10 | 15 | 20 | 7 |
| 2 | Si Li | 85 | 65 | 92 | 88 | 21 | 15 | 6 | 2 |
根据唯一性原则，(pivot)新表的行索引等价于对index中的多列使用drop_duplicates，而列索引的长度为values中的元素个数乘以columns的唯一组合数量（与index类似） 。
- pivot_table
pivot的使用依赖于唯一性条件，那如果不满足唯一性条件，那么必须通过聚合操作使得相同行列组合对应的多个值变为一个值。
例如，张三和李四都参加了两次语文考试和数学考试，按照学院规定，最后的成绩是两次考试分数的平均值，此时就无法通过pivot函数来完成。
df = 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]})
df
| Name | Subject | Grade | |
|---|---|---|---|
| 0 | San Zhang | Chinese | 80 |
| 1 | San Zhang | Chinese | 90 |
| 2 | San Zhang | Math | 100 |
| 3 | San Zhang | Math | 90 |
| 4 | Si Li | Chinese | 70 |
| 5 | Si Li | Chinese | 80 |
| 6 | Si Li | Math | 85 |
| 7 | Si Li | Math | 95 |
pandas中提供了pivot_table来实现，其中的aggfunc参数就是使用的聚合函数。上述场景可以如下写出：
df.pivot_table(index = 'Name',
columns = 'Subject',
values = 'Grade',
aggfunc = 'mean')
| Subject | Chinese | Math |
|---|---|---|
| Name | ||
| San Zhang | 85 | 95 |
| Si Li | 75 | 90 |
此外，pivot_table具有边际汇总的功能，可以通过设置margins=True来实现，其中边际的聚合方式与aggfunc中给出的聚合方法一致。下面就分别统计了语文均分和数学均分、张三均分和李四均分，以及总体所有分数的均分：
df.pivot_table(index = 'Name',
columns = 'Subject',
values = 'Grade',
aggfunc='mean',
margins=True)
| Subject | Chinese | Math | All |
|---|---|---|---|
| Name | |||
| San Zhang | 85 | 95.0 | 90.00 |
| Si Li | 75 | 90.0 | 82.50 |
| All | 80 | 92.5 | 86.25 |
【练一练】
在上面的边际汇总例子中，行或列的汇总为新表中行元素或者列元素的平均值，而总体的汇总为新表中四个元素的平均值。这种关系一定成立吗？若不成立，请给出一个例子来说明。
df_err = 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, None, 100, 90, 70, 80, 85, 95]})
df_err.pivot_table(index = 'Name',
columns = 'Subject',
values = 'Grade',
aggfunc='mean',
margins=True)
| Subject | Chinese | Math | All |
|---|---|---|---|
| Name | |||
| San Zhang | 80.000000 | 95.0 | 90.000000 |
| Si Li | 75.000000 | 90.0 | 82.500000 |
| All | 76.666667 | 92.5 | 85.714286 |
(80.000000+75.00000+95+90)/4.0
85.0
不一定，部分元素为None时,会引起总数的变化,求mean时会剔除掉None。
在图中可以看到，Chinese中的第一列的All的值为76/67 ！= （80+75）/2
[end]
- melt (熔化,把宽表转为长表)
在下面的例子中，Subject以列索引的形式存储，现在想要将其压缩到一个列中。
df = pd.DataFrame({'Class':[1,2],
'Name':['San Zhang', 'Si Li'],
# 有两门学科,Grade分类为Chinese或者math
'Chinese':[80, 90],
'Math':[80, 75]})
df
| Class | Name | Chinese | Math | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | 80 | 80 |
| 1 | 2 | Si Li | 90 | 75 |
df_melted=df.melt(id_vars = ['Class', 'Name'],
value_vars = ['Chinese', 'Math'],
var_name = 'Subject',
value_name = 'Grade')
df_melted
| Class | Name | Subject | Grade | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | Chinese | 80 |
| 1 | 2 | Si Li | Chinese | 90 |
| 2 | 1 | San Zhang | Math | 80 |
| 3 | 2 | Si Li | Math | 75 |
melt和pivot是一组互逆过程，那么就一定可以通过pivot操作把df_melted转回df的形式：
df_unmelted = df_melted.pivot(index = ['Class', 'Name'],
columns='Subject',
values='Grade')
df_unmelted
| Subject | Chinese | Math | |
|---|---|---|---|
| Class | Name | ||
| 1 | San Zhang | 80 | 80 |
| 2 | Si Li | 90 | 75 |
df_unmelted_reset_index = df_unmelted.reset_index().rename_axis(columns={'Subject':''})
# df_unmelted.equals(df)
df_unmelted_reset_index
| Class | Name | Chinese | Math | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | 80 | 80 |
| 1 | 2 | Si Li | 90 | 75 |
df_unmelted.equals(df)
False
- wide_to_long
elt 方法中，在列索引中被压缩的一组值对应的列元素只能代表同一层次的含义，即 values_name 。
现在如果列中包含了交叉类别，比如期中期末的类别和语文数学的类别，那么想要把 values_name 对应的 Grade 扩充为两列分别对应语文分数和数学分数，只把期中期末的信息压缩，这种需求下就要使用 wide_to_long 函数来完成。
df = pd.DataFrame({'Class':[1,2],'Name':['San Zhang', 'Si Li'],
'Chinese_Mid':[80, 75], 'Math_Mid':[90, 85],
'Chinese_Final':[80, 75], 'Math_Final':[90, 85]})
df
| Class | Name | Chinese_Mid | Math_Mid | Chinese_Final | Math_Final | |
|---|---|---|---|---|---|---|
| 0 | 1 | San Zhang | 80 | 90 | 80 | 90 |
| 1 | 2 | Si Li | 75 | 85 | 75 | 85 |
pd.wide_to_long(df,
# stubnames表示转换后的列名称
stubnames=['Chinese', 'Math'],
# 索引列的名称
i = ['Class', 'Name'],
# 压缩到每行的变量名含义
j='Examination',
sep='_',
suffix='.+')
| Chinese | Math | |||
|---|---|---|---|---|
| Class | Name | Examination | ||
| 1 | San Zhang | Mid | 80 | 90 |
| Final | 80 | 90 | ||
| 2 | Si Li | Mid | 75 | 85 |
| Final | 75 | 85 |
更多见下面的解析图片
下面给出一个比较复杂的案例，把之前在pivot一节中多列操作的结果（产生了多级索引），利用wide_to_long函数，将其转为原来的形态。其中，使用了第八章的str.split函数，目前暂时只需将其理解为对序列按照某个分隔符进行拆分即可。
# 例子
res = pivot_multi.copy()
res.columns = res.columns.map(lambda x:'_'.join(x))
res = res.reset_index()
res = pd.wide_to_long(res, stubnames=['Grade', 'rank'],
i = ['Class', 'Name'],
j = 'Subject_Examination',
sep = '_',
suffix = '.+')
res
| Grade | rank | |||
|---|---|---|---|---|
| Class | Name | Subject_Examination | ||
| 1 | San Zhang | Chinese_Mid | 80 | 10 |
| Chinese_Final | 75 | 15 | ||
| Math_Mid | 90 | 20 | ||
| Math_Final | 85 | 7 | ||
| 2 | Si Li | Chinese_Mid | 85 | 21 |
| Chinese_Final | 65 | 15 | ||
| Math_Mid | 92 | 6 | ||
| Math_Final | 88 | 2 |
# 续上
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
| Class | Name | Examination | Subject | Grade | rank | |
|---|---|---|---|---|---|---|
| 0 | 1 | San Zhang | Mid | Chinese | 80 | 10 |
| 1 | 1 | San Zhang | Final | Chinese | 75 | 15 |
| 2 | 2 | Si Li | Mid | Chinese | 85 | 21 |
| 3 | 2 | Si Li | Final | Chinese | 65 | 15 |
| 4 | 1 | San Zhang | Mid | Math | 90 | 20 |
| 5 | 1 | San Zhang | Final | Math | 85 | 7 |
| 6 | 2 | Si Li | Mid | Math | 92 | 6 |
| 7 | 2 | Si Li | Final | Math | 88 | 2 |
二、索引的变形
1. stack与unstack
在第二章中提到了利用swaplevel或者reorder_levels进行索引内部的层交换，下面就要讨论(color{red}{行列索引之间})的交换，由于这种交换带来了DataFrame维度上的变化，因此属于变形操作。
在第一节中提到的4种变形函数与其不同之处在于，它们都属于某一列或几列(color{red}{元素})和(color{red}{列索引})之间的转换，而不是索引之间的转换。
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
| col_1 | col_2 | |||
|---|---|---|---|---|
| A | cat | big | 1.0 | 1.0 |
| dog | small | 1.0 | 1.0 | |
| B | cat | big | 1.0 | 1.0 |
| dog | small | 1.0 | 1.0 |
df.unstack().unstack()
| col_1 | col_2 | |||||||
|---|---|---|---|---|---|---|---|---|
| big | small | big | small | |||||
| cat | dog | cat | dog | cat | dog | cat | dog | |
| A | 1.0 | NaN | NaN | 1.0 | 1.0 | NaN | NaN | 1.0 |
| B | 1.0 | NaN | NaN | 1.0 | 1.0 | NaN | NaN | 1.0 |
unstack的主要参数是移动的层号，默认转化最内层，移动到列索引的最内层，同时支持同时转化多个层：
df.unstack([0,2])
| col_1 | col_2 | |||||||
|---|---|---|---|---|---|---|---|---|
| A | B | A | B | |||||
| big | small | big | small | big | small | big | small | |
| cat | 1.0 | NaN | 1.0 | NaN | 1.0 | NaN | 1.0 | NaN |
| dog | NaN | 1.0 | NaN | 1.0 | NaN | 1.0 | NaN | 1.0 |
类似于pivot中的唯一性要求，在unstack中必须保证(color{red}{被转为列索引的行索引层})和(color{red}{被保留的行索引层})构成的组合是唯一的，例如把前两个列索引改成相同的破坏唯一性，那么就会报错：
my_index = df.index.to_list()
my_index[1] = my_index[0]
df.index = pd.Index(my_index)
df
| col_1 | col_2 | |||
|---|---|---|---|---|
| A | cat | big | 1.0 | 1.0 |
| big | 1.0 | 1.0 | ||
| B | cat | big | 1.0 | 1.0 |
| dog | small | 1.0 | 1.0 |
try:
df.unstack()
except Exception as e:
Err_Msg = e
Err_Msg
ValueError('Index contains duplicate entries, cannot reshape')
与unstack相反，stack的作用就是把列索引的层压入行索引，其用法完全类似。
2. 聚合与变形的关系
- 聚合：分组聚合操作，由于生成了新的行列索引，因此必然也属于某种特殊的变形操作，但由于聚合之后把原来的多个值变为了一个值，因此values的个数产生了变化
- 变形：除了带有聚合效果的pivot_table以外，所有的函数在变形前后并不会带来values个数的改变，只是这些值在呈现的形式上发生了变化
三、其他变形函数
1. crosstab
crosstab并不是一个值得推荐使用的函数，因为它能实现的所有功能pivot_table都能完成，并且速度更快。
在默认状态下，crosstab可以统计元素组合出现的频数，即count操作。例如统计learn_pandas数据集中学校和转系情况对应的频数：
df = pd.read_csv('E:\PycharmProjects\DatawhaleChina\joyful-pandas\data\learn_pandas.csv')
pd.crosstab(index = df.School, columns = df.Transfer)
| Transfer | N | Y |
|---|---|---|
| School | ||
| Fudan University | 38 | 1 |
| Peking University | 28 | 2 |
| Shanghai Jiao Tong University | 53 | 0 |
| Tsinghua University | 62 | 4 |
同样，可以利用pivot_table进行等价操作，由于这里统计的是组合的频数，因此values参数无论传入哪一个列都不会影响最后的结果：
df.pivot_table(index = 'School',
columns = 'Transfer',
values = 'Name',
aggfunc = 'count')
| Transfer | N | Y |
|---|---|---|
| School | ||
| Fudan University | 38.0 | 1.0 |
| Peking University | 28.0 | 2.0 |
| Shanghai Jiao Tong University | 53.0 | NaN |
| Tsinghua University | 62.0 | 4.0 |
【练一练】
前面提到了crosstab的性能劣于pivot_table，请选用多个聚合方法进行验证。
使用
%timeit -n 100 ___ 即可
2. 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
| A | B | |
|---|---|---|
| 0 | [1, 2] | 1 |
| 1 | my_str | 1 |
| 2 | {1, 2} | 1 |
| 3 | 0 3 1 4 dtype: int64 | 1 |
df_ex.explode('A')
| A | B | |
|---|---|---|
| 0 | 1 | 1 |
| 0 | 2 | 1 |
| 1 | my_str | 1 |
| 2 | {1, 2} | 1 |
| 3 | 3 | 1 |
| 3 | 4 | 1 |
- get_dummies (虚拟向量,ont-hot)
get_dummies是用于特征构建的重要函数之一，其作用是把类别特征转为指示变量。例如，对年级一列转为指示变量，属于某一个年级的对应列标记为1，否则为0：
pd.get_dummies(df.Grade).head()
| Freshman | Junior | Senior | Sophomore | |
|---|---|---|---|---|
| 0 | 1 | 0 | 0 | 0 |
| 1 | 1 | 0 | 0 | 0 |
| 2 | 0 | 0 | 1 | 0 |
| 3 | 0 | 0 | 0 | 1 |
| 4 | 0 | 0 | 0 | 1 |
四、练习
Ex1：美国非法药物数据集
现有一份关于美国非法药物的数据集，其中SubstanceName, DrugReports分别指药物名称和报告数量：
df = pd.read_csv('E:\PycharmProjects\DatawhaleChina\joyful-pandas\data\drugs.csv').sort_values(['State','COUNTY','SubstanceName'],ignore_index=True)
df.head(3)
| YYYY | State | COUNTY | SubstanceName | DrugReports | |
|---|---|---|---|---|---|
| 0 | 2011 | KY | ADAIR | Buprenorphine | 3 |
| 1 | 2012 | KY | ADAIR | Buprenorphine | 5 |
| 2 | 2013 | KY | ADAIR | Buprenorphine | 4 |
- 将数据转为如下的形式：
df_pivot = df.pivot_table(index=['State','COUNTY','SubstanceName'],
columns = 'YYYY',
values = 'DrugReports'
).rename_axis(columns={'YYYY':''})
df_pivot
| 2010 | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | 2017 | |||
|---|---|---|---|---|---|---|---|---|---|---|
| State | COUNTY | SubstanceName | ||||||||
| KY | ADAIR | Buprenorphine | NaN | 3.0 | 5.0 | 4.0 | 27.0 | 5.0 | 7.0 | 10.0 |
| Codeine | NaN | NaN | 1.0 | NaN | NaN | NaN | NaN | 1.0 | ||
| Fentanyl | NaN | NaN | 1.0 | NaN | NaN | NaN | NaN | NaN | ||
| Heroin | NaN | NaN | 1.0 | 2.0 | NaN | 1.0 | NaN | 2.0 | ||
| Hydrocodone | 6.0 | 9.0 | 10.0 | 10.0 | 9.0 | 7.0 | 11.0 | 3.0 | ||
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| WV | WOOD | Oxycodone | 6.0 | 4.0 | 24.0 | 7.0 | 7.0 | 11.0 | 7.0 | 1.0 |
| Tramadol | NaN | NaN | NaN | NaN | 1.0 | NaN | 4.0 | 3.0 | ||
| WYOMING | Buprenorphine | NaN | 1.0 | 1.0 | 1.0 | NaN | NaN | NaN | 1.0 | |
| Hydrocodone | 1.0 | 5.0 | NaN | NaN | 1.0 | NaN | 1.0 | NaN | ||
| Oxycodone | 5.0 | 4.0 | 14.0 | 12.0 | 5.0 | NaN | NaN | NaN |
6214 rows × 8 columns
df_pivot = df_pivot.reset_index()
df_melt = df_pivot.melt(
id_vars=['State','COUNTY','SubstanceName'],
value_vars = df_pivot.columns[-8:],
var_name = 'YYYY',
value_name='DrugReports')
df_melt = df_melt.dropna(subset=['DrugReports'])
df_melt
| State | COUNTY | SubstanceName | YYYY | DrugReports | |
|---|---|---|---|---|---|
| 4 | KY | ADAIR | Hydrocodone | 2010 | 6.0 |
| 6 | KY | ADAIR | Methadone | 2010 | 1.0 |
| 13 | KY | ALLEN | Hydrocodone | 2010 | 10.0 |
| 15 | KY | ALLEN | Methadone | 2010 | 4.0 |
| 17 | KY | ALLEN | Oxycodone | 2010 | 15.0 |
| ... | ... | ... | ... | ... | ... |
| 49702 | WV | WOOD | Hydrocodone | 2017 | 8.0 |
| 49704 | WV | WOOD | Isobutyryl fentanyl | 2017 | 3.0 |
| 49707 | WV | WOOD | Oxycodone | 2017 | 1.0 |
| 49708 | WV | WOOD | Tramadol | 2017 | 3.0 |
| 49709 | WV | WYOMING | Buprenorphine | 2017 | 1.0 |
24062 rows × 5 columns
- 将第1问中的结果恢复为原表。
df_melt= df_melt[df.columns].sort_values(['State','COUNTY','SubstanceName'],ignore_index=True).astype({'YYYY':'int64', 'DrugReports':'int64'})
df_melt.equals(df)
True
- 按
State分别统计每年的报告数量总和，其中State, YYYY分别为列索引和行索引，要求分别使用pivot_table函数与groupby+unstack两种不同的策略实现，并体会它们之间的联系。
# 策略一
res = df.pivot_table(index='YYYY', columns='State', values='DrugReports', aggfunc='sum')
res
| State | KY | OH | PA | VA | WV |
|---|---|---|---|---|---|
| YYYY | |||||
| 2010 | 10453 | 19707 | 19814 | 8685 | 2890 |
| 2011 | 10289 | 20330 | 19987 | 6749 | 3271 |
| 2012 | 10722 | 23145 | 19959 | 7831 | 3376 |
| 2013 | 11148 | 26846 | 20409 | 11675 | 4046 |
| 2014 | 11081 | 30860 | 24904 | 9037 | 3280 |
| 2015 | 9865 | 37127 | 25651 | 8810 | 2571 |
| 2016 | 9093 | 42470 | 26164 | 10195 | 2548 |
| 2017 | 9394 | 46104 | 27894 | 10448 | 1614 |
# 策略二
df.groupby(['State', 'YYYY'])['DrugReports'].sum().to_frame().unstack(0).droplevel(0, axis=1)
| State | KY | OH | PA | VA | WV |
|---|---|---|---|---|---|
| YYYY | |||||
| 2010 | 10453 | 19707 | 19814 | 8685 | 2890 |
| 2011 | 10289 | 20330 | 19987 | 6749 | 3271 |
| 2012 | 10722 | 23145 | 19959 | 7831 | 3376 |
| 2013 | 11148 | 26846 | 20409 | 11675 | 4046 |
| 2014 | 11081 | 30860 | 24904 | 9037 | 3280 |
| 2015 | 9865 | 37127 | 25651 | 8810 | 2571 |
| 2016 | 9093 | 42470 | 26164 | 10195 | 2548 |
| 2017 | 9394 | 46104 | 27894 | 10448 | 1614 |
Ex2：特殊的wide_to_long方法
从功能上看， melt 方法应当属于 wide_to_long 的一种特殊情况，即 stubnames 只有一类。请使用 wide_to_long 生成 melt 一节中的 df_melted 。（提示：对列名增加适当的前缀）
df = pd.DataFrame({'Class':[1,2],
'Name':['San Zhang', 'Si Li'],
'Chinese':[80, 90],
'Math':[80, 75]})
df
| Class | Name | Chinese | Math | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | 80 | 80 |
| 1 | 2 | Si Li | 90 | 75 |
df_melted=df.melt(id_vars = ['Class', 'Name'],
value_vars = ['Chinese', 'Math'],
var_name = 'Subject',
value_name = 'Grade')
df_melted
| Class | Name | Subject | Grade | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | Chinese | 80 |
| 1 | 2 | Si Li | Chinese | 90 |
| 2 | 1 | San Zhang | Math | 80 |
| 3 | 2 | Si Li | Math | 75 |
# 使用 wide_to_long 生成 melt 一节中的 df_melted
df_wtl = df.rename(columns={'Chinese':'my_Chinese', 'Math':'my_Math'})
df_wtl = pd.wide_to_long(df_wtl,
stubnames=['my'],
i = ['Class', 'Name'],
j='Subject',
sep='_',
suffix='.+').reset_index().rename(columns={'my':'Grade'})
df_wtl
| Class | Name | Subject | Grade | |
|---|---|---|---|---|
| 0 | 1 | San Zhang | Chinese | 80 |
| 1 | 1 | San Zhang | Math | 80 |
| 2 | 2 | Si Li | Chinese | 90 |
| 3 | 2 | Si Li | Math | 75 |