第五章变形

最新推荐文章于 2022-08-20 20:50:36 发布

Mounvo

最新推荐文章于 2022-08-20 20:50:36 发布

阅读量150

点赞数

分类专栏： dataWhale python

本文链接：https://blog.csdn.net/Mounvo/article/details/111828681

版权

dataWhale 同时被 2 个专栏收录

20 篇文章 1 订阅

订阅专栏

python

7 篇文章 0 订阅

订阅专栏

第五章变形

一、长宽表的变形

一个表中把性别存储在某一个列中，那么它就是关于性别的长表，如果性别的值包含在列名中，列中的元素是某一其他的相关特征数值，那么这个表是关于性别的宽表。也可以理解为，就性别这一特征来说，长表的一行数据量少，行数多，宽表的一行数据量大，行数少。

下面的两张表就分别是关于性别的长表和宽表：

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的状态存储。

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

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

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

#         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	85			95.0	90.00
# Si Li			75			90.0	82.50
# All				80			92.5	86.25

3. melt

melt函数将宽表转为长表。在下面的例子中，Subject以列索引的形式存储，现在想要将其压缩到一个列中。

df = pd.DataFrame({'Class':[1,2],
                   'Name':['San Zhang', 'Si Li'],
                   'Chinese':[80, 90],
                   'Math':[80, 75]})
# 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')
#    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

也可以使用pivot将df_melted还原回去。

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

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

下面给出一个比较复杂的案例，把之前在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 = 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进行索引内部的层交换，下面就要讨论行列索引之间行列索引之间的交换，由于这种交换带来了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

Mounvo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第五章变形

第五章变形一、长宽表的变形一个表中把性别存储在某一个列中，那么它就是关于性别的长表，如果性别的值包含在列名中，列中的元素是某一其他的相关特征数值，那么这个表是关于性别的宽表。也可以理解为，就性别这一特征来说，长表的一行数据量少，行数多，宽表的一行数据量大，行数少。下面的两张表就分别是关于性别的长表和宽表：pd.DataFrame({'Gender':['F','F','M','M'], 'Height':[163, 160, 175, 180]})# Gender Height# 0 F
复制链接

扫一扫