【12月DW打卡】joyful-pandas

第五章 pandas变形

import numpy as np
import pandas as pd

一、长宽表的变形

• 举例性别列，用一列存储为长表，用两列（男、女）分别存储为宽表
• pandas针对此类长宽表的变形操作设计了一些有关的变形函数。
• jupyter nbconvert --to markdown E:PycharmProjectsTianChiProject0_山枫叶纷飞competitions08_joyful-pandas5_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类似） 。

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]})
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]

3. 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

4. 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

3. 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

1. 将数据转为如下的形式：

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

2. 将第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

3. 按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