pandas 05-变形

Pandas 05-变形

import numpy as np
import pandas as pd

一、长宽表的变形

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

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

显然这两张表从信息上是完全等价的，它们包含相同的身高统计数值，只是这些数值的呈现方式不同，而其呈现方式主要又与性别一列选择的布局模式有关，即到底是以$long$的状态存储还是以$wide$的状态存储。因此，pandas针对此类长宽表的变形操作设计了一些有关的变形函数。

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对应了想要展示的数值列。

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:
    print(e)

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

	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

现在想要把测试类型和科目联合组成的四个类别（期中语文、期末语文、期中数学、期末数学）转到列索引，并且同时统计成绩和排名：

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

根据唯一性原则，新表的行索引等价于对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

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

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中给出的聚合方法一致。下面就分别统计了语文均分和数学均分、张三均分和李四均分，以及总体所有分数的均分：

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

Subject	Chinese	Math	All
Name
San Zhang	77.50	87.50	82.5
Si Li	75.00	90.00	82.5
All	76.25	88.75	82.5

【练一练 - 01】

在上面的边际汇总例子中，行或列的汇总为新表中行元素或者列元素的平均值，而总体的汇总为新表中四个元素的平均值。这种关系一定成立吗？若不成立，请给出一个例子来说明。

My solution :

• 不一定成立
• 依题意我们想到可能有三种方式得到最终的汇总结果
• 方式1 : 用原表中的数据汇总

df['Grade'].mean()

82.5

• 方式2 : 设置margins为False , 手动将pivot后的结果汇总

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

82.5

• 方式3 : 设置margins为True , 此时会多一行一列都为All的汇总结果 , 取出['All','All']对应的汇总结果

df.pivot_table(index = 'Name',
               columns = 'Subject',
               values = 'Grade',
               aggfunc = 'mean',
               margins = True).loc['All','All']

82.5

• 我们发现这三种方式的汇总结果一致 , 再来尝试其他聚合函数
• 将上一章提到的很多种聚合函数copy过来用split分割后遍历
• 把上述三种方式中的聚合函数分别对应位置格式化为aggfuncs里遍历到的聚合函数
• 打印遍历到的聚合函数名
• 尝试对比方式2与方式3得出的结果是否一致
• 尝试对比方式1与方式3得出的结果是否一致

aggfuncs = 'max/min/mean/median/count/all/any/idxmax/idxmin/mad/nunique/skew/quantile/sum/std/var/sem/size/prod'.split('/')

for func in aggfuncs:
    method_1 = f'''df['Grade'].{func}()'''
    method_2 = f'''df.pivot_table(index = 'Name',
                              columns = 'Subject',
                              values = 'Grade',
                              aggfunc = '{func}',
                              margins = False).{func}().{func}()'''
    method_3 = f'''df.pivot_table(index = 'Name',
                              columns = 'Subject',
                              values = 'Grade',
                              aggfunc = '{func}',
                              margins = True).loc['All','All']'''
    
    print(f'{func} :', end='\t')
    try:
        print(eval(method_2) == eval(method_3), end='\t')
    except Exception as e:
        print(e, end='\t')
        
    try:
        print(eval(method_1) == eval(method_3))
    except Exception as e:
        print(e)

max :	True	True
min :	True	True
mean :	True	True
median :	False	True
count :	False	True
all :	True	True
any :	True	True
idxmax :	reduction operation 'argmax' not allowed for this dtype	True
idxmin :	reduction operation 'argmin' not allowed for this dtype	True
mad :	False	True
nunique :	False	True
skew :	No objects to concatenate	No objects to concatenate
quantile :	False	True
sum :	True	True
std :	False	True
var :	False	True
sem :	False	True
size :	'numpy.int32' object is not callable	'int' object is not callable
prod :	True	True

• 可以看到第一列是使用的聚合函数名
• 中间一列是方式2与方式3的对比 , 其中所有的False值对应的聚合函数都可以作为不成立的例子 , 但结果为True的却不能说明一定成立 , 是因为数据可能具有巧合性得出了True的结果 , 因此结果为True对应的聚合函数要单独用数学或逻辑推导出是否真的为True
• 第三列是方式1与方式3的对比 , 其中除了异常值全为True , 这说明margins参数的汇总是按原表数据汇总的 , 而非基于pivot后的表数据再汇总

【END】

3. melt

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

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

melt的主要参数和压缩的过程如下图所示：

前面提到了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 = df_unmelted.reset_index().rename_axis(columns={'Subject':''})
df_unmelted.equals(df)

True

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

df = pd.DataFrame({'Class':[1,2],'Name':['San Zhang', 'Si Li'],
                   'Chinese_Mid':[80, 75],
                   'Chinese_Final':[80, 75]})
df

	Class	Name	Chinese_Mid	Chinese_Final
0	1	San Zhang	80	80
1	2	Si Li	75	75

pd.wide_to_long(df,
                stubnames=['Chinese'],
                i = ['Class', 'Name'],
                j = 'Examination',
                sep = '_',
                suffix = '.+')

			Chinese
Class	Name	Examination
1	San Zhang	Mid	80
		Final	80
2	Si Li	Mid	75
		Final	75

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	NaN
		Final	80	NaN
2	Si Li	Mid	75	NaN
		Final	75	NaN

具体的变换过程由下图进行展示，属相同概念的元素使用了一致的颜色标出：

下面给出一个比较复杂的案例，把之前在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 = 'Examination_Subject',
                           sep = '_',
                           suffix = '.+')
res = res.reset_index()
res[['Examination', 'Subject']] = res['Examination_Subject'].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进行索引内部的层交换，下面就要讨论$行列索引之间$的交换，由于这种交换带来了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

			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()

		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的主要参数是移动的层号，默认转化最内层，移动到列索引的最内层，同时支持同时转化多个层：

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

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()
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的作用就是把列索引的层压入行索引，其用法完全类似。

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

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

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

2. 聚合与变形的关系

在上面介绍的所有函数中，除了带有聚合效果的pivot_table以外，所有的函数在变形前后并不会带来values个数的改变，只是这些值在呈现的形式上发生了变化。在上一章讨论的分组聚合操作，由于生成了新的行列索引，因此必然也属于某种特殊的变形操作，但由于聚合之后把原来的多个值变为了一个值，因此values的个数产生了变化，这也是分组聚合与变形函数的最大区别。

三、其他变形函数

1. crosstab

crosstab并不是一个值得推荐使用的函数，因为它能实现的所有功能pivot_table都能完成，并且速度更快。在默认状态下，crosstab可以统计元素组合出现的频数，即count操作。例如统计learn_pandas数据集中学校和转系情况对应的频数：

df = pd.read_csv('../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

这等价于如下crosstab的如下写法，这里的aggfunc即聚合参数：

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统计，所有的聚合字符串和返回标量的自定义函数都是可用的，例如统计对应组合的身高均值：

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

【练一练 - 02】

前面提到了crosstab的性能劣于pivot_table，请选用多个聚合方法进行验证。

My solution :

• 同上一题一样 , 遍历aggfuncs , 将func传入对应位置 , 用timeit魔法指令测试200次均值 , 可以发现pivot_table的性能更优

aggfuncs = 'max/min/mean/median/count/all/any/idxmax/idxmin/mad/nunique/skew/quantile/sum/std/var/sem/size/prod'.split('/')

for func in aggfuncs:
    pivot_table = f'''df.pivot_table(index = 'School',
                                     columns = 'Transfer',
                                     values = 'Height',
                                     aggfunc = '{func}')'''
    crosstab = f'''pd.crosstab(index = df.School, 
                               columns = df.Transfer, 
                               values = df.Height, 
                               aggfunc = '{func}')'''
    print(f'{func}\t\tpivot_table:')
    try:
        %timeit -n 200 eval(pivot_table)
    except Exception as e:
        print(e)
    print(f'{func}\t\tcrosstab:')
    try:
        %timeit -n 200 eval(crosstab)
    except Exception as e:
        print(e)
    print('-------------------------------------------------------------------------')

max		pivot_table:
7.58 ms ± 611 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
max		crosstab:
7.89 ms ± 468 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
min		pivot_table:
7.67 ms ± 473 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
min		crosstab:
7.83 ms ± 230 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
mean		pivot_table:
7.3 ms ± 507 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
mean		crosstab:
7.82 ms ± 716 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
median		pivot_table:
7.3 ms ± 416 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
median		crosstab:
7.86 ms ± 450 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
count		pivot_table:
7.2 ms ± 373 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
count		crosstab:
7.72 ms ± 602 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
all		pivot_table:
8.56 ms ± 613 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
all		crosstab:
8.93 ms ± 832 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
any		pivot_table:
7.96 ms ± 201 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
any		crosstab:
8.78 ms ± 280 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
idxmax		pivot_table:
12.2 ms ± 583 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
idxmax		crosstab:
12.6 ms ± 291 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
idxmin		pivot_table:
12.3 ms ± 336 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
idxmin		crosstab:
14.3 ms ± 1.76 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
mad		pivot_table:
19 ms ± 1.75 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)
mad		crosstab:
18.2 ms ± 908 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
nunique		pivot_table:
9.07 ms ± 991 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
nunique		crosstab:
9.32 ms ± 717 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
skew		pivot_table:
12.2 ms ± 722 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
skew		crosstab:
12.6 ms ± 485 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
quantile		pivot_table:
7.74 ms ± 572 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
quantile		crosstab:
8.42 ms ± 511 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
sum		pivot_table:
8.2 ms ± 524 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
sum		crosstab:
8.67 ms ± 870 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
std		pivot_table:
8.22 ms ± 775 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
std		crosstab:
8.57 ms ± 430 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
var		pivot_table:
7.48 ms ± 454 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
var		crosstab:
8.24 ms ± 1.16 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
sem		pivot_table:
10 ms ± 1.03 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)
sem		crosstab:
9.65 ms ± 625 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------
size		pivot_table:
4.01 ms ± 390 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
size		crosstab:
'__dummy__'
-------------------------------------------------------------------------
prod		pivot_table:
7.73 ms ± 346 µs per loop (mean ± std. dev. of 7 runs, 200 loops each)
prod		crosstab:
8.88 ms ± 1.24 ms per loop (mean ± std. dev. of 7 runs, 200 loops each)
-------------------------------------------------------------------------

【END】

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

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('../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. 将数据转为如下的形式：

2. 将第1问中的结果恢复为原表。
3. 按State分别统计每年的报告数量总和，其中State, YYYY分别为列索引和行索引，要求分别使用pivot_table函数与groupby+unstack两种不同的策略实现，并体会它们之间的联系。

My solution :

1. 观察表中State,COUNTY,SubstanceName这三列被去重了 , YYYY列的值被移到了column上 , DrugReports单列填充一个值 , 应该为pivot变形 , 按参数填好值变形后重置索引 , 再将多余的YYYY名字去掉

df1 = df.pivot(index = ['State','COUNTY','SubstanceName'],
               columns = 'YYYY',
               values = 'DrugReports').reset_index().rename_axis(columns={'YYYY':''})
df1.head()

	State	COUNTY	SubstanceName	2010	2011	2012	2013	2014	2015	2016	2017
0	KY	ADAIR	Buprenorphine	NaN	3.0	5.0	4.0	27.0	5.0	7.0	10.0
1	KY	ADAIR	Codeine	NaN	NaN	1.0	NaN	NaN	NaN	NaN	1.0
2	KY	ADAIR	Fentanyl	NaN	NaN	1.0	NaN	NaN	NaN	NaN	NaN
3	KY	ADAIR	Heroin	NaN	NaN	1.0	2.0	NaN	1.0	NaN	2.0
4	KY	ADAIR	Hydrocodone	6.0	9.0	10.0	10.0	9.0	7.0	11.0	3.0

2. 用melt将pivot后的表逆变换回去 , 并设置好对应的参数 , 但由于pivot后的值不是一一对应的 , 变换后会多出很多NaN , 需追加去除NaN的行

df2 = df1.melt(id_vars = ['State','COUNTY','SubstanceName'],
               value_vars = range(2010,2018),
               var_name = 'YYYY',
               value_name = 'DrugReports').dropna(subset = ['DrugReports'])
df2.head(3)

	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

• 将变换后的列名顺序与原df变一致后按题干中的变换操作一次
• 此时还没有与原df完全相等 , 查看二者info信息

df2 = df2[df.columns].sort_values(['State','COUNTY','SubstanceName'],ignore_index=True)
df2.info()

RangeIndex: 24062 entries, 0 to 24061
Data columns (total 5 columns):
 #   Column         Non-Null Count  Dtype  
---  ------         --------------  -----  
 0   YYYY           24062 non-null  object 
 1   State          24062 non-null  object 
 2   COUNTY         24062 non-null  object 
 3   SubstanceName  24062 non-null  object 
 4   DrugReports    24062 non-null  float64
dtypes: float64(1), object(4)
memory usage: 940.0+ KB

df.info()

RangeIndex: 24062 entries, 0 to 24061
Data columns (total 5 columns):
 #   Column         Non-Null Count  Dtype 
---  ------         --------------  ----- 
 0   YYYY           24062 non-null  int64 
 1   State          24062 non-null  object
 2   COUNTY         24062 non-null  object
 3   SubstanceName  24062 non-null  object
 4   DrugReports    24062 non-null  int64 
dtypes: int64(2), object(3)
memory usage: 940.0+ KB

• 除了两个Dtype不一样 , 其他都一样 , 把两个不一样的Dtype重新设定后与原df相等

df2.astype({'YYYY':'int64','DrugReports':'int64'}).equals(df)

True

3. 按要求先用pivot_table填入对应参数 , 用sum对每年的DrugReports求和

df.pivot_table(index = 'YYYY', columns = 'State', values = 'DrugReports', aggfunc = 'sum').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

• 用groupby+unstack实现 , 按YYYY和State列聚合 , 对DrugReports求sum转为DataFrame , 用unstack将多级行索引的level1转为列索引 , 删除列索引level0

df.groupby(['YYYY', 'State'])['DrugReports'].sum().to_frame().unstack(1).droplevel(0,axis=1).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]})
df

	Class	Name	Chinese	Math
0	1	San Zhang	80	80
1	2	Si Li	90	75

My solution :

• 经尝试wide_to_long参数stubnames不可与原columns名完全一样 , 而是原columns从前向后的正则匹配一部分 , 并且这个参数的值会当做变形后的列名 , 因此先起个前缀Score供其正则匹配

df.rename(columns={'Chinese':'ScoreChinese','Math':'ScoreMath'}, inplace=True)
df

	Class	Name	ScoreChinese	ScoreMath
0	1	San Zhang	80	80
1	2	Si Li	90	75

• 用wide_to_long传入df , 设置index列为Class和Name , 正则匹配前缀为自定义的Score , 匹配剩下的部分用j参数设置为Subject , 再重置索引即可

pd.wide_to_long(df,
                stubnames=['Score'],
                i=['Class', 'Name'],
                j='Subject',
                suffix='.+').reset_index()

	Class	Name	Subject	Score
0	1	San Zhang	Chinese	80
1	1	San Zhang	Math	80
2	2	Si Li	Chinese	90
3	2	Si Li	Math	75