pandas学习-变形-task15
第五章 变形
一、长宽表的变形
什么是长表？什么是宽表？这个概念是对于某一个特征而言的。例如：一个表中把性别存储在某一个列中，那么它就是关于性别的长表；如果把性别作为列名，列中的元素是某一其他的相关特征数值，那么这个表是关于性别的宽表。下面的两张表就分别是关于性别的长表和宽表：
print(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
print(pd.DataFrame({
'Height: F':[163, 160],'Height: M':[175, 180]}))#关于性别的短表
# Height: F Height: M
# 0 163 175
# 1 160 180
显然这两张表从信息上是完全等价的，它们包含相同的身高统计数值，只是这些数值的呈现方式不同，而其呈现方式主要又与性别一列选择的布局模式有关，即到底是以 long 的状态存储还是以 wide 的状态存储。
- 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]})
print(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 对应了想要展示的数值列。
print(df.pivot(index='Name', columns='Subject', values='Grade'))
# Subject Chinese Math
# Name
# San Zhang 80 75
# Si Li 90 85
通过颜色的标记，更容易地能够理解其变形的过程：
利用 pivot 进行变形操作需要满足唯一性的要求，即由于在新表中的行列索引对应了唯一的 value ，因此原表中的 index 和 columns 对应两个列的行组合必须唯一。例如，现在把原表中第二行张三的数学改为语文就会报错，这是由于 Name 与 Subject 的组合中两次出现 ("San Zhang", "Chinese") ，从而最后不能够确定到底变形后应该是填写80分还是75分。
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]})
print(df)
现在想要把测试类型和科目联合组成的四个类别（期中语文、期末语文、期中数学、期末数学）转到列索引，并且同时统计成绩和排名：
pivot_multi = df.pivot(index = ['Class', 'Name'],
columns = ['Subject','Examination'],
values = ['Grade','rank'])
print(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
根据唯一性原则，新表的行索引等价于对 index 中的多列使用 drop_duplicates ，而列索引的长度为 values 中的元素个数乘以 columns 的唯一组合数量（与 index 类似） 。从下面的示意图中能够比较容易地理解相应的操作：
2. 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]})
print(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 参数就是使用的聚合函数。上述场景可以如下写出：
print(df.pivot_table(index = 'Name',columns = 'Subject',values = 'Grade',aggfunc = 'mean'))
# Subject Chinese Math
# Name
# San Zhang 85 95
# Si Li 75 90
这里传入 aggfunc 包含了上一章中介绍的所有合法聚合字符串，此外还可以传入以序列为输入标量为输出的聚合函数来实现自定义操作，上述功能可以等价写出：
print(df.pivot_table(index = 'Name',
columns = 'Subject',
values = 'Grade',
aggfunc = lambda x:x.mean()))
# Subject Chinese Math
# Name
# San Zhang 85 95
# Si Li 75 90
此外， pivot_table 具有边际汇总的功能，可以通过设置 margins=True 来实现，其中边际的聚合方式与 aggfunc 中给出的聚合方法一致。下面就分别统计了语文均分和数学均分、张三均分和李四均分，以及总体所有分数的均分：
print(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
- melt
长宽表只是数据呈现方式的差异，但其包含的信息量是等价的，前面提到了利用 pivot 把长表转为宽表，那么就可以通过相应的逆操作把宽表转为长表， melt 函数就起到了这样的作用。在下面的例子中， Subject 以列索引的形式存储，现在想要将其压缩到一个列中。
df = pd.DataFrame({
'Class':[1,2],
'Name':['San Zhang', 'Si Li'],
'Chinese':[80, 90],
'Math':[80, 75]})
print(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')
print(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 的主要参数和压缩的过程如下图所示：
前面提到了 melt 和 pivot 是一组互逆过程，那么就一定可以通过 pivot 操作把 df_melted 转回 df 的形式：
df_unmelted = df_melted.pivot(index = ['Class', 'Name'],
columns='Subject',
values='Grade')
print(df_unmelted)
# Subject Chinese Math
# Class Name
# 1 San Zhang 80 80
# 2 Si Li 90 75
df_unmelted = df_unmelted.reset_index().rename_axis(columns={
'Subject':''})#重命名列索引名称
print(df_unmelted)
# Class Name Chinese Math
# 0 1 San Zhang 80 80
# 1 2 Si Li 90 75
df_unmelted.equals(df)
# True
- wide_to_long
melt 方法中，在列索引中被压缩的一组值对应的列元素只能代表同一层次的含义，即 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]})
print(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
print(pd.wide_to_long(df,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
具体的变换过程由下图进行展示，属相同概念的元素使用了一致的颜色标出：
suffix（一般默认是过滤数字 如果是字符需要额外用suffix）
下面给出一个比较复杂的案例，把之前在 pivot 一节中多列操作的结果（产生了多级索引），利用 wide_to_long 函数，将其转为原来的形态。其中，使用了第八章的 str.split 函数，目前暂时只需将其理解为对序列按照某个分隔符进行拆分即可。
res = pivot_multi.copy()
print(res)
# 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
res.columns = res.columns.map(lambda x:'_'.join(x))#多级列索引的拆解
print(res.columns)
# Index(['Grade_Chinese_Mid', 'Grade_Chinese_Final', 'Grade_Math_Mid',
# 'Grade_Math_Final', 'rank_Chinese_Mid', 'rank_Chinese_Final',
# 'rank_Math_Mid', 'rank_Math_Final'],
# dtype='object')
res = res.reset_index()
print(res)
# Class Name Grade_Chinese_Mid Grade_Chinese_Final Grade_Math_Mid \
# 0 1 San Zhang 80 75 90
# 1 2 Si Li 85 65 92
# Grade_Math_Final rank_Chinese_Mid rank_Chinese_Final rank_Math_Mid \
# 0 85 10 15 20
# 1 88 21 15 6
# rank_Math_Final
# 0 7
# 1 2
res = pd.wide_to_long(res, stubnames=['Grade', 'rank'],
i = ['Class', 'Name'],
j = 'Subject_Examination',
sep = '_',
suffix = '.+')
print(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()
print(res)
# Class Name Subject_Examination Grade rank
# 0 1 San Zhang Chinese_Mid 80 10
# 1 1 San Zhang Chinese_Final 75 15
# 2 1 San Zhang Math_Mid 90 20
# 3 1 San Zhang Math_Final 85 7
# 4 2 Si Li Chinese_Mid 85 21
# 5 2 Si Li Chinese_Final 65 15
# 6 2 Si Li Math_Mid 92 6
# 7 2 Si Li Math_Final 88 2
res[['Subject', 'Examination']] = res['Subject_Examination'].str.split('_', expand=True)
print(res)
# Class Name Subject_Examination Grade rank Subject Examination
# 0 1 San Zhang Chinese_Mid 80 10 Chinese Mid
# 1 1 San Zhang Chinese_Final 75 15 Chinese Final
# 2 1 San Zhang Math_Mid 90 20 Math Mid
# 3 1 San Zhang Math_Final 85 7 Math Final
# 4 2 Si Li Chinese_Mid 85 21 Chinese Mid
# 5 2 Si Li Chinese_Final 65 15 Chinese Final
# 6 2 Si Li Math_Mid 92 6 Math Mid
# 7 2 Si Li Math_Final 88 2 Math Final
res = res[['Class', 'Name', 'Examination','Subject', 'Grade', 'rank']].sort_values('Subject')
print(res)
# Class Name Examination Subject Grade rank
# 0 1 San Zhang Mid Chinese 80 10
# 1 1 San Zhang Final Chinese 75 15
# 4 2 Si Li Mid Chinese 85 21
# 5 2 Si Li Final Chinese 65 15
# 2 1 San Zhang Mid Math 90 20
# 3 1 San Zhang Final Math 85 7
# 6 2 Si Li Mid Math 92 6
# 7 2 Si Li Final Math 88 2
res = res.reset_index(drop=True)#drop: 重新设置索引后是否将原索引作为新的一列并入DataFrame，默认为False
print(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
二、索引的变形
-
stack与unstack
在第二章中提到了利用 swaplevel 或者 reorder_levels 进行索引内部的层交换，下面就要讨论 行列索引之间 的交换，由于这种交换带来了 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'])
print(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
print(df.unstack())#默认转化最内层
# col_1 col_2
# big small big small
# A cat 1.0 NaN 1.0 NaN
# dog NaN 1.0 NaN 1.0
# B cat 1.0 NaN 1.0 NaN
# dog NaN 1.0 NaN 1.0
unstack 的主要参数是移动的层号，默认转化最内层，移动到列索引的最内层，同时支持同时转化多个层：
print(df.unstack(2))
# col_1 col_2
# big small big small
# A cat 1.0 NaN 1.0 NaN
# dog NaN 1.0 NaN 1.0
# B cat 1.0 NaN 1.0 NaN
# dog NaN 1.0 NaN 1.0
print(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 中必须保证 被转为列索引的行索引层 和 被保留的行索引层 构成的组合是唯一的，例如把前两个列索引改成相同的破坏唯一性，那么就会报错：
my_index = df.index.to_list()
print(my_index)
# [('A', 'cat', 'big'), ('A', 'dog', 'small'), ('B', 'cat', 'big'), ('B', 'dog', 'small')]
my_index[1] = my_index[0]
print(my_index)
# [('A', 'cat', 'big'), ('A', 'cat', 'big'), ('B', 'cat', 'big'), ('B', 'dog', 'small')]
df.index = pd.Index(my_index)
print(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 的作用就是把列索引的层压入行索引，其用法完全类似。
df = 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
print(df)
# A B
# cat dog cat dog
# big small big small
# index_1 1.0 1.0 1.0 1.0
# index_2 1.0 1.0 1.0 1.0
print(df.stack())
# A B
# cat dog cat dog
# index_1 big 1.0 NaN 1.0 NaN
# small NaN 1.0 NaN 1.0
# index_2 big 1.0 NaN 1.0 NaN
# small NaN 1.0 NaN 1.0
print(df.stack([1, 2]))
# A B
# index_1 cat big 1.0 1.0
# dog small 1.0 1.0
# index_2 cat big 1.0 1.0
# dog small 1.0 1.0
- 聚合与变形的关系
在上面介绍的所有函数中，除了带有聚合效果的 pivot_table 以外，所有的函数在变形前后并不会带来 values 个数的改变，只是这些值在呈现的形式上发生了变化。在上一章讨论的分组聚合操作，由于生成了新的行列索引，因此必然也属于某种特殊的变形操作，但由于聚合之后把原来的多个值变为了一个值，因此 values 的个数产生了变化，这也是分组聚合与变形函数的最大区别。
三、其他变形函数 - crosstab
crosstab 并不是一个值得推荐使用的函数，因为它能实现的所有功能 pivot_table 都能完成，并且速度更快。在默认状态下， crosstab 可以统计元素组合出现的频数，即 count 操作。例如统计 learn_pandas 数据集中学校和转系情况对应的频数：
df = pd.read_csv('E:/document/python学习笔记/pandas学习/learn_pandas.csv')
df.head()
print(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
这等价于如下 crosstab 的如下写法，这里的 aggfunc 即聚合参数：
print(pd.crosstab(index = df.School, columns = df.Transfer,
values = [0]*df.shape[0], 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
同样，可以利用 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 传入的是被调用表对应的名字，若传入序列对应的值则会报错。
除了默认状态下的 count 统计，所有的聚合字符串和返回标量的自定义函数都是可用的，例如统计对应组合的身高均值：
print(pd.crosstab(index = df.School, columns = df.Transfer,
values = df.Height, aggfunc = 'mean'))
# Transfer N Y
# School
# Fudan University 162.043750 177.20
# Peking University 163.429630 162.40
# Shanghai Jiao Tong University 163.953846 NaN
# Tsinghua University 163.253571 164.55
- explode
explode 参数能够对某一列的元素进行纵向的展开，被展开的单元格必须存储 list, tuple, Series, np.ndarray 中的一种类型。
df_ex = pd.DataFrame({
'A': [[1, 2],
'my_str',
{
1, 2},
pd.Series([3, 4])],
'B': 1})
print(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
get_dummies 是用于特征构建的重要函数之一，其作用是把类别特征转为指示变量。例如，对年级一列转为指示变量，属于某一个年级的对应列标记为1，否则为0：
print(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:/document/python学习笔记/pandas学习/drugs.csv').sort_values(['State','COUNTY','SubstanceName'],ignore_index=True)
print(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 = pd.read_csv('E:/document/python学习笔记/pandas学习/drugs.csv').sort_values(
['State','COUNTY','SubstanceName'],ignore_index=True)
df.head(3)
df_pivot=df.pivot(index=['State','COUNTY','SubstanceName'], columns='YYYY', values='DrugReports')
df_pivot=df_pivot.reset_index().rename_axis(columns={
'YYYY':''})
df_pivot.head()
df_melted=df_pivot.melt(id_vars = ['State','COUNTY','SubstanceName'],
value_vars = df_pivot.columns[-8:],
var_name = 'YYYY',
value_name = 'DrugReports').dropna(subset=['DrugReports'])
#dropna(subset=['DrugReports'])丢弃'DrugReports'这列中有缺失值的行
print(df_melted.head())
# 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
df_melted = df_melted[df.columns].sort_values(['State','COUNTY','SubstanceName'],ignore_index=True).astype({
'YYYY':'int64', 'DrugReports':'int64'})
print(df_melted.head())
# YYYY State COUNTY SubstanceName DrugReports
# 0 2011 KY ADAIR Buprenorphine 3
# 1 2012 KY ADAIR Buprenorphine 5
# 2 2013 KY ADAIR Buprenorphine 4
# 3 2014 KY ADAIR Buprenorphine 27
# 4 2015 KY ADAIR Buprenorphine 5
df_melted.equals(df)
# True
res = df.groupby(['State', 'YYYY'])['DrugReports'].sum().to_frame().unstack(0).droplevel(0,axis=1)
print(res.head())
# 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
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]})
print(df)
# Class Name Chinese Math
# 0 1 San Zhang 80 80
# 1 2 Si Li 90 75
df = df.rename(columns={
'Chinese':'pre_Chinese', 'Math':'pre_Math'})
print(pd.wide_to_long(df,
stubnames=['pre'],
i = ['Class', 'Name'],
j='Subject',
sep='_',
suffix='.+').reset_index().rename(columns={
'pre':'Grade'}))
# 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