变形

5.1 长宽表的变形

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

import numpy as np
import pandas as pd
pd.DataFrame({'Gender':['F','F','M','M'],'Height':[163, 160, 175, 180]})
GenderHeight
0F163
1F160
2M175
3M180
pd.DataFrame({'Height: F':[163, 160],'Height: M':[175, 180]})
Height: FHeight: M
0163175
1160180

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

5.1.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
ClassNameSubjectGrade
01San ZhangChinese80
11San ZhangMath75
22Si LiChinese90
32Si LiMath85

对于一个基本的长变宽的操作而言,最重要的有三个要素,分别是变形后的行索引、需要转到列索引的列,
以及这些列和行索引对应的数值,它们分别对应了pivot 方法中的index, columns, values 参数。新生成表的列索引是columns 对应列的unique 值,而新表的行索引是index 对应列的unique 值,而values 对应了想要展示的数值列。

df.pivot(index='Name', columns='Subject', values='Grade')
SubjectChineseMath
Name
San Zhang8075
Si Li9085

通过颜色的标记,更容易地能够理解其变形的过程:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oOof1WEy-1609077303080)(attachment:image.png)]

利用pivot 进行变形操作需要满足唯一性的要求,即由于在新表中的行列索引对应了唯一的value ,因此原表中的index 和columns 对应两个列的行组合必须唯一。例如,现在把原表中第二行张三的数学改为语文就会报错,这是由于Name 与Subject 的组合中两次出现(”San Zhang”, ”Chinese”) ,从而最后不能够确定到底变形后应该是填写80 分还是75 分。

df.loc[1, 'Subject'] = 'Chinese'

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
ClassNameExaminationSubjectGraderank
01San ZhangMidChinese8010
11San ZhangFinalChinese7515
22Si LiMidChinese8521
32Si LiFinalChinese6515
41San ZhangMidMath9020
51San ZhangFinalMath857
62Si LiMidMath926
72Si LiFinalMath882

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

pivot_multi = df.pivot(index = ['Class', 'Name'],
                       columns = ['Subject','Examination'],
                       values = ['Grade','rank'])
pivot_multi
Graderank
SubjectChineseMathChineseMath
ExaminationMidFinalMidFinalMidFinalMidFinal
ClassName
1San Zhang807590851015207
2Si Li85659288211562

根据唯一性原则,新表的行索引等价于对index 中的多列使用drop_duplicates ,而列索引的长度为values中的元素个数乘以columns 的唯一组合数量(与index 类似)。从下面的示意图中能够比较容易地理解相应
的操作:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l6iyPVp1-1609077303090)(attachment:image.png)]

5.1.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
NameSubjectGrade
0San ZhangChinese80
1San ZhangChinese90
2San ZhangMath100
3San ZhangMath90
4Si LiChinese70
5Si LiChinese80
6Si LiMath85
7Si LiMath95

pandas 中提供了pivot_table 来实现,其中的aggfunc 参数就是使用的聚合函数。上述场景可以如下写出:

df.pivot_table(index = 'Name',
               columns = 'Subject',
               values = 'Grade',
               aggfunc = 'mean')
SubjectChineseMath
Name
San Zhang8595
Si Li7590

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

df.pivot_table(index = 'Name',
               columns = 'Subject',
               values = 'Grade',
               aggfunc = lambda x:x.mean())
SubjectChineseMath
Name
San Zhang8595
Si Li7590

此外,pivot_table 具有边际汇总的功能,可以通过设置margins=True 来实现,其中边际的聚合方式与aggfunc 中给出的聚合方法一致。下面就分别统计了语文均分和数学均分、张三均分和李四均分,以及总体所有分数的均分:

df.pivot_table(index = 'Name',
               columns = 'Subject',
               aggfunc='mean',
               margins=True)
Grade
SubjectChineseMathAll
Name
San Zhang8595.090.00
Si Li7590.082.50
All8092.586.25

5.1.3 melt

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

df = pd.DataFrame({'Class':[1,2],
                   'Name':['San Zhang', 'Si Li'],
                   'Chinese':[80, 90],
                   'Math':[80, 75]})
df
ClassNameChineseMath
01San Zhang8080
12Si Li9075
df_melted = df.melt(id_vars = ['Class', 'Name'],
                    value_vars = ['Chinese', 'Math'],
                    var_name = 'Subject',
                    value_name = 'Grade')
df_melted
ClassNameSubjectGrade
01San ZhangChinese80
12Si LiChinese90
21San ZhangMath80
32Si LiMath75

melt 的主要参数和压缩的过程如下图所示:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bj24alze-1609077303097)(attachment:image.png)]

前面提到了melt 和pivot 是一组互逆过程,那么就一定可以通过pivot 操作把df_melted 转回df 的形式:

df_unmelted = df_melted.pivot(index = ['Class', 'Name'],columns='Subject',values='Grade')
df_unmelted # 下面需要恢复索引,并且重命名列索引名称
SubjectChineseMath
ClassName
1San Zhang8080
2Si Li9075
df_unmelted = df_unmelted.reset_index().rename_axis(columns={'Subject':''})
df_unmelted.equals(df)
True

5.1.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
ClassNameChinese_MidMath_MidChinese_FinalMath_Final
01San Zhang80908090
12Si Li75857585
pd.wide_to_long(df,stubnames=['Chinese', 'Math'],i = ['Class', 'Name'],j='Examination',sep='_',suffix='.+')
ChineseMath
ClassNameExamination
1San ZhangMid8090
Final8090
2Si LiMid7585
Final7585

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pL2P31Fj-1609077303107)(attachment:image.png)]

下面给出一个比较复杂的案例,把之前在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
ClassNameExaminationSubjectGraderank
01San ZhangMidChinese8010
11San ZhangFinalChinese7515
22Si LiMidChinese8521
32Si LiFinalChinese6515
41San ZhangMidMath9020
51San ZhangFinalMath857
62Si LiMidMath926
72Si LiFinalMath882

5.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'])
df
col_1col_2
Acatbig1.01.0
dogsmall1.01.0
Bcatbig1.01.0
dogsmall1.01.0
df.unstack()
col_1col_2
bigsmallbigsmall
Acat1.0NaN1.0NaN
dogNaN1.0NaN1.0
Bcat1.0NaN1.0NaN
dogNaN1.0NaN1.0

unstack 的主要参数是移动的层号,默认转化最内层,移动到列索引的最内层,同时支持同时转化多个层:

df.unstack(2)
df.unstack([0,2])
col_1col_2
ABAB
bigsmallbigsmallbigsmallbigsmall
cat1.0NaN1.0NaN1.0NaN1.0NaN
dogNaN1.0NaN1.0NaN1.0NaN1.0

类似于pivot 中的唯一性要求,在unstack 中必须保证被转为列索引的行索引层和被保留的行索引层构成的组合是唯一的,例如把前两个列索引改成相同的破坏唯一性,那么就会报错:

my_index = df.index.to_list()
my_index[1] = my_index[0]
df.index = pd.Index(my_index)
df
col_1col_2
Acatbig1.01.0
big1.01.0
Bcatbig1.01.0
dogsmall1.01.0

与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
AB
catdogcatdog
bigsmallbigsmall
index_11.01.01.01.0
index_21.01.01.01.0
df.stack()
AB
catdogcatdog
index_1big1.0NaN1.0NaN
smallNaN1.0NaN1.0
index_2big1.0NaN1.0NaN
smallNaN1.0NaN1.0
df.stack([1, 2])
---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-39-859b38663e73> in <module>
----> 1 df.stack([1, 2])


D:\anaconda3\lib\site-packages\pandas\core\frame.py in stack(self, level, dropna)
   7001 
   7002         if isinstance(level, (tuple, list)):
-> 7003             return stack_multiple(self, level, dropna=dropna)
   7004         else:
   7005             return stack(self, level, dropna=dropna)


D:\anaconda3\lib\site-packages\pandas\core\reshape\reshape.py in stack_multiple(frame, level, dropna)
    559         # _get_level_number() checks level numbers are in range and converts
    560         # negative numbers to positive
--> 561         level = [frame.columns._get_level_number(lev) for lev in level]
    562 
    563         # Can't iterate directly through level as we might need to change


D:\anaconda3\lib\site-packages\pandas\core\reshape\reshape.py in <listcomp>(.0)
    559         # _get_level_number() checks level numbers are in range and converts
    560         # negative numbers to positive
--> 561         level = [frame.columns._get_level_number(lev) for lev in level]
    562 
    563         # Can't iterate directly through level as we might need to change


D:\anaconda3\lib\site-packages\pandas\core\indexes\base.py in _get_level_number(self, level)
   1413 
   1414     def _get_level_number(self, level) -> int:
-> 1415         self._validate_index_level(level)
   1416         return 0
   1417 


D:\anaconda3\lib\site-packages\pandas\core\indexes\base.py in _validate_index_level(self, level)
   1405             elif level > 0:
   1406                 raise IndexError(
-> 1407                     f"Too many levels: Index has only 1 level, not {level + 1}"
   1408                 )
   1409         elif level != self.name:


IndexError: Too many levels: Index has only 1 level, not 2

5.2.2 聚合与变形的关系

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

5.3 其他变形函数

5.3.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)
pd.crosstab(index = df.School, columns = df.Transfer,values = [0]*df.shape[0], aggfunc = 'count')
TransferNY
School
Fudan University38.01.0
Peking University28.02.0
Shanghai Jiao Tong University53.0NaN
Tsinghua University62.04.0

同样,可以利用pivot_table 进行等价操作,由于这里统计的是组合的频数,因此values 参数无论传入哪一个列都不会影响最后的结果:

df.pivot_table(index = 'School',columns = 'Transfer',values = 'Name',aggfunc = 'count')
TransferNY
School
Fudan University38.01.0
Peking University28.02.0
Shanghai Jiao Tong University53.0NaN
Tsinghua University62.04.0

从上面可以看出这两个函数的区别在于,crosstab 的对应位置传入的是具体的序列,而pivot_table 传入的
是被调用表对应的名字,若传入序列对应的值则会报错。
除了默认状态下的count 统计,所有的聚合字符串和返回标量的自定义函数都是可用的,例如统计对应组合
的身高均值:

pd.crosstab(index = df.School, columns = df.Transfer,values = df.Height, aggfunc = 'mean')
TransferNY
School
Fudan University162.043750177.20
Peking University163.429630162.40
Shanghai Jiao Tong University163.953846NaN
Tsinghua University163.253571164.55

5.3.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.explode('A')
AB
011
021
1my_str1
2{1, 2}1
331
341

5.3.3 get_dummies

get_dummies 是用于特征构建的重要函数之一,其作用是把类别特征转为指示变量。例如,对年级一列转为指示变量,属于某一个年级的对应列标记为1,否则为0:

pd.get_dummies(df.Grade).head()
FreshmanJuniorSeniorSophomore
01000
11000
20010
30001
40001
## 练习
到时候再补!!!
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值