专业的外贸网站建设,有什么网站建设类岗位,各大网站推荐,个人怎么注册家族公司目录一、层次化索引重排与分级排序根据级别汇总统计二、合并数据集数据库风格的DataFrame合并索引上的合并轴向连接合并重叠数据三、重塑和轴向旋转重塑层次化索引将“长格式”旋转为“宽格式”将“宽格式”旋转为“长格式”一、层次化索引
层次化索引#xff08;hierarchica…
目录一、层次化索引重排与分级排序根据级别汇总统计二、合并数据集数据库风格的DataFrame合并索引上的合并轴向连接合并重叠数据三、重塑和轴向旋转重塑层次化索引将“长格式”旋转为“宽格式”将“宽格式”旋转为“长格式”一、层次化索引
层次化索引hierarchical indexing是pandas的一项重要功能它使你能在一个轴上拥有多个两个以上索引级别。抽象点说它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子创建一个Series并用一个由列表或数组组成的列表作为索引
In [9]: data pd.Series(np.random.randn(9),...: index[[a, a, a, b, b, c, c, d, d],...: [1, 2, 3, 1, 3, 1, 2, 2, 3]])In [10]: data
Out[10]:
a 1 -0.2047082 0.4789433 -0.519439
b 1 -0.5557303 1.965781
c 1 1.3934062 0.092908
d 2 0.2817463 0.769023
dtype: float64看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”
In [11]: data.index
Out[11]:
MultiIndex(levels[[a, b, c, d], [1, 2, 3]],labels[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])对于一个层次化索引的对象可以使用所谓的部分索引使用它选取数据子集的操作更简单
In [12]: data[b]
Out[12]:
1 -0.555730
3 1.965781
dtype: float64In [13]: data[b:c]
Out[13]:
b 1 -0.5557303 1.965781
c 1 1.3934062 0.092908
dtype: float64In [14]: data.loc[[b, d]]
Out[14]:
b 1 -0.5557303 1.965781
d 2 0.2817463 0.769023
dtype: float64有时甚至还可以在“内层”中进行选取
In [15]: data.loc[:, 2]
Out[15]:
a 0.478943
c 0.092908
d 0.281746
dtype: float64对于一个DataFrame每条轴都可以有分层索引
In [18]: frame pd.DataFrame(np.arange(12).reshape((4, 3)),....: index[[a, a, b, b], [1, 2, 1, 2]],....: columns[[Ohio, Ohio, Colorado],....: [Green, Red, Green]])In [19]: frame
Out[19]: Ohio ColoradoGreen Red Green
a 1 0 1 22 3 4 5
b 1 6 7 82 9 10 11各层都可以有名字可以是字符串也可以是别的Python对象。如果指定了名称它们就会显示在控制台输出中
In [20]: frame.index.names [key1, key2]In [21]: frame.columns.names [state, color]In [22]: frame
Out[22]:
state Ohio Colorado
color Green Red Green
key1 key2
a 1 0 1 22 3 4 5
b 1 6 7 82 9 10 11重排与分级排序
有时你需要重新调整某条轴上各级别的顺序或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称并返回一个互换了级别的新对象但数据不会发生变化
In [24]: frame.swaplevel(key1, key2)
Out[24]:
state Ohio Colorado
color Green Red Green
key2 key1
1 a 0 1 2
2 a 3 4 5
1 b 6 7 8
2 b 9 10 11而sort_index则根据单个级别中的值对数据进行排序。交换级别时常常也会用到sort_index这样最终结果就是按照指定顺序进行字母排序了
In [25]: frame.sort_index(level1)
Out[25]:
state Ohio Colorado
color Green Red Green
key1 key2
a 1 0 1 2
b 1 6 7 8
a 2 3 4 5
b 2 9 10 11In [26]: frame.swaplevel(0, 1).sort_index(level0)
Out[26]:
state Ohio Colorado
color Green Red Green
key2 key1
1 a 0 1 2b 6 7 8
2 a 3 4 5b 9 10 11根据级别汇总统计
许多对DataFrame和Series的描述和汇总统计都有一个level选项它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例我们可以根据行或列上的级别来进行求和
In [27]: frame.sum(levelkey2)
Out[27]:
state Ohio Colorado
color Green Red Green
key2
1 6 8 10
2 12 14 16In [28]: frame.sum(levelcolor, axis1)
Out[28]:
color Green Red
key1 key2
a 1 2 12 8 4
b 1 14 72 20 10DataFrame的set_index函数会将其一个或多个列转换为行索引并创建一个新的DataFrame
In [29]: frame pd.DataFrame({a: range(7), b: range(7, 0, -1),....: c: [one, one, one, two, two,....: two, two],....: d: [0, 1, 2, 0, 1, 2, 3]})In [30]: frame
Out[30]: a b c d
0 0 7 one 0
1 1 6 one 1
2 2 5 one 2
3 3 4 two 0
4 4 3 two 1
5 5 2 two 2
6 6 1 two 3默认情况下那些列会从DataFrame中移除但也可以将其保留下来
In [33]: frame.set_index([c, d], dropFalse)
Out[33]: a b c d
c d
one 0 0 7 one 01 1 6 one 12 2 5 one 2
two 0 3 4 two 01 4 3 two 12 5 2 two 23 6 1 two 3reset_index的功能跟set_index刚好相反层次化索引的级别会被转移到列里面 In [34]: frame2.reset_index()
Out[34]:
c d a b
0 one 0 0 7
1 one 1 1 6
2 one 2 2 5
3 two 0 3 4
4 two 1 4 3
5 two 2 5 2
6 two 3 6 1二、合并数据集
pandas对象中的数据可以通过一些方式进行合并
pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉因为它实现的就是数据库的join操作。pandas.concat可以沿着一条轴将多个对象堆叠到一起。实例方法combine_first可以将重复数据拼接在一起用一个对象中的值填充另一个对象中的缺失值。 我将分别对它们进行讲解并给出一些例子。本书剩余部分的示例中将经常用到它们。
数据库风格的DataFrame合并
数据集的合并merge或连接join运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库基于SQL的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
以一个简单的例子开始
In [35]: df1 pd.DataFrame({key: [b, b, a, c, a, a, b],....: data1: range(7)})In [36]: df2 pd.DataFrame({key: [a, b, d],....: data2: range(3)})In [37]: df1
Out[37]: data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 a
6 6 bIn [38]: df2
Out[38]: data2 key
0 0 a
1 1 b
2 2 d这是一种多对一的合并。df1中的数据有多个被标记为a和b的行而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到
In [39]: pd.merge(df1, df2)
Out[39]: data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0注意我并没有指明要用哪个列进行连接。如果没有指定merge就会将重叠列的列名当做键。不过最好明确指定一下
In [40]: pd.merge(df1, df2, onkey)
Out[40]: data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0如果两个对象的列名不同也可以分别进行指定
In [41]: df3 pd.DataFrame({lkey: [b, b, a, c, a, a, b],....: data1: range(7)})In [42]: df4 pd.DataFrame({rkey: [a, b, d],....: data2: range(3)})In [43]: pd.merge(df3, df4, left_onlkey, right_onrkey)
Out[43]: data1 lkey data2 rkey
0 0 b 1 b
1 1 b 1 b
2 6 b 1 b
3 2 a 0 a
4 4 a 0 a
5 5 a 0 a可能你已经注意到了结果里面c和d以及与之相关的数据消失了。默认情况下merge做的是“内连接”结果中的键是交集。其他方式还有left、“right以及outer”。外连接求取的是键的并集组合了左连接和右连接的效果
In [44]: pd.merge(df1, df2, howouter)
Out[44]: data1 key data2
0 0.0 b 1.0
1 1.0 b 1.0
2 6.0 b 1.0
3 2.0 a 0.0
4 4.0 a 0.0
5 5.0 a 0.0
6 3.0 c NaN
7 NaN d 2.0多键合并
In [51]: left pd.DataFrame({key1: [foo, foo, bar],....: key2: [one, two, one],....: lval: [1, 2, 3]})In [52]: right pd.DataFrame({key1: [foo, foo, bar, bar],....: key2: [one, one, one, two],....: rval: [4, 5, 6, 7]})In [53]: pd.merge(left, right, on[key1, key2], howouter)
Out[53]: key1 key2 lval rval
0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN
3 bar one 3.0 6.0
4 bar two NaN 7.0对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题查看前面介绍的重命名轴标签但merge有一个更实用的suffixes选项用于指定附加到左右两个DataFrame对象的重叠列名上的字符串
In [54]: pd.merge(left, right, onkey1)
Out[54]: key1 key2_x lval key2_y rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7In [55]: pd.merge(left, right, onkey1, suffixes(_left, _right))
Out[55]: key1 key2_left lval key2_right rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7索引上的合并
有时候DataFrame中的连接键位于其索引中。在这种情况下你可以传入left_indexTrue或right_indexTrue或两个都传以说明索引应该被用作连接键
In [56]: left1 pd.DataFrame({key: [a, b, a, a, b, c],....: value: range(6)})In [57]: right1 pd.DataFrame({group_val: [3.5, 7]}, index[a, b])In [58]: left1
Out[58]:key value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5In [59]: right1
Out[59]: group_val
a 3.5
b 7.0In [60]: pd.merge(left1, right1, left_onkey, right_indexTrue)
Out[60]: key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0由于默认的merge方法是求取连接键的交集因此你可以通过外连接的方式得到它们的并集
In [61]: pd.merge(left1, right1, left_onkey, right_indexTrue, howouter)
Out[61]: key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
5 c 5 NaNDataFrame还有一个便捷的join实例方法它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象但要求没有重叠的列。在上面那个例子中我们可以编写
In [73]: left2.join(right2, howouter)
Out[73]: Ohio Nevada Missouri Alabama
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0轴向连接
另一种数据合并运算也被称作连接concatenation、绑定binding或堆叠stacking。NumPy的concatenation函数可以用NumPy数组来做
In [79]: arr np.arange(12).reshape((3, 4))In [80]: arr
Out[80]:
array([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])In [81]: np.concatenate([arr, arr], axis1)
Out[81]:
array([[ 0, 1, 2, 3, 0, 1, 2, 3],[ 4, 5, 6, 7, 4, 5, 6, 7],[ 8, 9, 10, 11, 8, 9, 10, 11]])对于pandas对象如Series和DataFrame带有标签的轴使你能够进一步推广数组的连接运算。具体点说你还需要考虑以下这些东西
如果对象在其它轴上的索引不同我们应该合并这些轴的不同元素还是只使用交集连接的数据集是否需要在结果对象中可识别连接轴中保存的数据是否需要保留许多情况下DataFrame默认的整数标签最好在连接时删掉。 pandas的concat函数提供了一种能够解决这些问题的可靠方式。我将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的Series
In [82]: s1 pd.Series([0, 1], index[a, b])In [83]: s2 pd.Series([2, 3, 4], index[c, d, e])In [84]: s3 pd.Series([5, 6], index[f, g])对这些对象调用concat可以将值和索引粘合在一起
In [85]: pd.concat([s1, s2, s3])
Out[85]:
a 0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64默认情况下concat是在axis0上工作的最终产生一个新的Series。如果传入axis1则结果就会变成一个DataFrameaxis1是列
In [86]: pd.concat([s1, s2, s3], axis1)
Out[86]: 0 1 2
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0你可以通过join_axes指定要在其它轴上使用的索引
In [91]: pd.concat([s1, s4], axis1, join_axes[[a, c, b, e]])
Out[91]: 0 1
a 0.0 0.0
c NaN NaN
b 1.0 1.0
e NaN NaN不过有个问题参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的
In [92]: result pd.concat([s1, s1, s3], keys[one,two, three])In [93]: result
Out[93]:
one a 0b 1
two a 0b 1
three f 5g 6
dtype: int64In [94]: result.unstack()
Out[94]: a b f g
one 0.0 1.0 NaN NaN
two 0.0 1.0 NaN NaN
three NaN NaN 5.0 6.0如果沿着axis1对Series进行合并则keys就会成为DataFrame的列头
In [95]: pd.concat([s1, s2, s3], axis1, keys[one,two, three])
Out[95]: one two three
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0 合并重叠数据
还有一种数据组合问题不能用简单的合并merge或连接concatenation运算来处理。比如说你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子我们使用NumPy的where函数它表示一种等价于面向数组的if-else
In [108]: a pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],.....: index[f, e, d, c, b, a])In [109]: b pd.Series(np.arange(len(a), dtypenp.float64),.....: index[f, e, d, c, b, a])In [110]: b[-1] np.nanIn [111]: a
Out[111]:
f NaN
e 2.5
d NaN
c 3.5
b 4.5
a NaN
dtype: float64In [112]: b
Out[112]:
f 0.0
e 1.0
d 2.0
c 3.0
b 4.0
a NaN
dtype: float64In [113]: np.where(pd.isnull(a), b, a)
Out[113]: array([ 0. , 2.5, 2. , 3.5, 4.5, nan])Series有一个combine_first方法实现的也是一样的功能还带有pandas的数据对齐
In [114]: b[:-2].combine_first(a[2:])
Out[114]:
a NaN
b 4.5
c 3.0
d 2.0
e 1.0
f 0.0
dtype: float64
对于DataFramecombine_first自然也会在列上做同样的事情因此你可以将其看做用传递对象中的数据为调用对象的缺失数据“打补丁”
In [115]: df1 pd.DataFrame({a: [1., np.nan, 5., np.nan],.....: b: [np.nan, 2., np.nan, 6.],.....: c: range(2, 18, 4)})In [116]: df2 pd.DataFrame({a: [5., 4., np.nan, 3., 7.],.....: b: [np.nan, 3., 4., 6., 8.]})In [117]: df1
Out[117]: a b c
0 1.0 NaN 2
1 NaN 2.0 6
2 5.0 NaN 10
3 NaN 6.0 14In [118]: df2
Out[118]: a b
0 5.0 NaN
1 4.0 3.0
2 NaN 4.0
3 3.0 6.0
4 7.0 8.0In [119]: df1.combine_first(df2)
Out[119]: a b c
0 1.0 NaN 2.0
1 4.0 2.0 6.0
2 5.0 4.0 10.0
3 3.0 6.0 14.0
4 7.0 8.0 NaN三、重塑和轴向旋转
有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑reshape或轴向旋转pivot运算。
重塑层次化索引
层次化索引为DataFrame数据的重排任务提供了一种具有良好一致性的方式。主要功能有二
stack将数据的列“旋转”为行。unstack将数据的行“旋转”为列。 我将通过一系列的范例来讲解这些操作。接下来看一个简单的DataFrame其中的行列索引均为字符串数组
In [120]: data pd.DataFrame(np.arange(6).reshape((2, 3)),.....: indexpd.Index([Ohio,Colorado], namestate),.....: columnspd.Index([one, two, three],.....: namenumber))In [121]: data
Out[121]:
number one two three
state
Ohio 0 1 2
Colorado 3 4 5
# 对该数据使用stack方法即可将列转换为行得到一个Series
In [122]: result data.stack()In [123]: result
Out[123]:
state number
Ohio one 0two 1three 2
Colorado one 3two 4three 5
dtype: int64
#对于一个层次化索引的Series你可以用unstack将其重排为一个DataFrame
In [124]: result.unstack()
Out[124]:
number one two three
state
Ohio 0 1 2
Colorado 3 4 5将“长格式”旋转为“宽格式”
多个时间序列数据通常是以所谓的“长格式”long或“堆叠格式”stacked存储在数据库和CSV中的。我们先加载一些示例数据做一些时间序列规整和数据清洗
In [139]: data pd.read_csv(examples/macrodata.csv)In [140]: data.head()
Out[140]: year quarter realgdp realcons realinv realgovt realdpi cpi \
0 1959.0 1.0 2710.349 1707.4 286.898 470.045 1886.9 28.98
1 1959.0 2.0 2778.801 1733.7 310.859 481.301 1919.7 29.15
2 1959.0 3.0 2775.488 1751.8 289.226 491.260 1916.4 29.35
3 1959.0 4.0 2785.204 1753.7 299.356 484.052 1931.3 29.37
4 1960.0 1.0 2847.699 1770.5 331.722 462.199 1955.5 29.54 m1 tbilrate unemp pop infl realint
0 139.7 2.82 5.8 177.146 0.00 0.00
1 141.7 3.08 5.1 177.830 2.34 0.74
2 140.5 3.82 5.3 178.657 2.74 1.09
3 140.0 4.33 5.6 179.386 0.27 4.06
4 139.6 3.50 5.2 180.007 2.31 1.19 In [141]: periods pd.PeriodIndex(yeardata.year, quarterdata.quarter,.....: namedate)In [142]: columns pd.Index([realgdp, infl, unemp], nameitem)In [143]: data data.reindex(columnscolumns)In [144]: data.index periods.to_timestamp(D, end)In [145]: ldata data.stack().reset_index().rename(columns{0: value})这就是多个时间序列或者其它带有两个或多个键的可观察数据这里我们的键是date和item的长格式。表中的每行代表一次观察。
关系型数据库如MySQL中的数据经常都是这样存储的因为固定架构即列名和数据类型有一个好处随着表中数据的添加item列中的值的种类能够增加。在前面的例子中date和item通常就是主键用关系型数据库的说法不仅提供了关系完整性而且提供了更为简单的查询支持。有的情况下使用这样的数据会很麻烦你可能会更喜欢DataFrame不同的item值分别形成一列date列中的时间戳则用作索引。DataFrame的pivot方法完全可以实现这个转换
In [147]: pivoted ldata.pivot(date, item, value)In [148]: pivoted
Out[148]:
item infl realgdp unemp
date
1959-03-31 0.00 2710.349 5.8
1959-06-30 2.34 2778.801 5.1
1959-09-30 2.74 2775.488 5.3
1959-12-31 0.27 2785.204 5.6
1960-03-31 2.31 2847.699 5.2
1960-06-30 0.14 2834.390 5.2
1960-09-30 2.70 2839.022 5.6
1960-12-31 1.21 2802.616 6.3
1961-03-31 -0.40 2819.264 6.8
1961-06-30 1.47 2872.005 7.0
... ... ... ...
2007-06-30 2.75 13203.977 4.5
2007-09-30 3.45 13321.109 4.7
2007-12-31 6.38 13391.249 4.8
2008-03-31 2.82 13366.865 4.9
2008-06-30 8.53 13415.266 5.4
2008-09-30 -3.16 13324.600 6.0
2008-12-31 -8.79 13141.920 6.9
2009-03-31 0.94 12925.410 8.1
2009-06-30 3.37 12901.504 9.2
2009-09-30 3.56 12990.341 9.6
[203 rows x 3 columns]前两个传递的值分别用作行和列索引最后一个可选值则是用于填充DataFrame的数据列。假设有两个需要同时重塑的数据列
In [149]: ldata[value2] np.random.randn(len(ldata))In [150]: ldata[:10]
Out[150]: date item value value2
0 1959-03-31 realgdp 2710.349 0.523772
1 1959-03-31 infl 0.000 0.000940
2 1959-03-31 unemp 5.800 1.343810
3 1959-06-30 realgdp 2778.801 -0.713544
4 1959-06-30 infl 2.340 -0.831154
5 1959-06-30 unemp 5.100 -2.370232
6 1959-09-30 realgdp 2775.488 -1.860761
7 1959-09-30 infl 2.740 -0.860757
8 1959-09-30 unemp 5.300 0.560145
9 1959-12-31 realgdp 2785.204 -1.265934如果忽略最后一个参数得到的DataFrame就会带有层次化的列
In [151]: pivoted ldata.pivot(date, item)In [152]: pivoted[:5]
Out[152]: value value2
item infl realgdp unemp infl realgdp unemp
date
1959-03-31 0.00 2710.349 5.8 0.000940 0.523772 1.343810
1959-06-30 2.34 2778.801 5.1 -0.831154 -0.713544 -2.370232
1959-09-30 2.74 2775.488 5.3 -0.860757 -1.860761 0.560145
1959-12-31 0.27 2785.204 5.6 0.119827 -1.265934 -1.063512
1960-03-31 2.31 2847.699 5.2 -2.359419 0.332883 -0.199543In [153]: pivoted[value][:5]
Out[153]:
item infl realgdp unemp
date
1959-03-31 0.00 2710.349 5.8
1959-06-30 2.34 2778.801 5.1
1959-09-30 2.74 2775.488 5.3
1959-12-31 0.27 2785.204 5.6
1960-03-31 2.31 2847.699 5.2注意pivot其实就是用set_index创建层次化索引再用unstack重塑
In [154]: unstacked ldata.set_index([date, item]).unstack(item)In [155]: unstacked[:7]
Out[155]: value value2
item infl realgdp unemp infl realgdp unemp
date
1959-03-31 0.00 2710.349 5.8 0.000940 0.523772 1.343810
1959-06-30 2.34 2778.801 5.1 -0.831154 -0.713544 -2.370232
1959-09-30 2.74 2775.488 5.3 -0.860757 -1.860761 0.560145
1959-12-31 0.27 2785.204 5.6 0.119827 -1.265934 -1.063512
1960-03-31 2.31 2847.699 5.2 -2.359419 0.332883 -0.199543
1960-06-30 0.14 2834.390 5.2 -0.970736 -1.541996 -1.307030
1960-09-30 2.70 2839.022 5.6 0.377984 0.286350 -0.753887将“宽格式”旋转为“长格式”
旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame而是合并多个列成为一个产生一个比输入长的DataFrame。看一个例子
In [157]: df pd.DataFrame({key: [foo, bar, baz],.....: A: [1, 2, 3],.....: B: [4, 5, 6],.....: C: [7, 8, 9]})In [158]: df
Out[158]: A B C key
0 1 4 7 foo
1 2 5 8 bar
2 3 6 9 bazkey列可能是分组指标其它的列是数据值。当使用pandas.melt我们必须指明哪些列是分组指标。下面使用key作为唯一的分组指标
In [159]: melted pd.melt(df, [key])In [160]: melted
Out[160]: key variable value
0 foo A 1
1 bar A 2
2 baz A 3
3 foo B 4
4 bar B 5
5 baz B 6
6 foo C 7
7 bar C 8
8 baz C 9使用pivot可以重塑回原来的样子
In [161]: reshaped melted.pivot(key, variable, value)In [162]: reshaped
Out[162]:
variable A B C
key
bar 2 5 8
baz 3 6 9
foo 1 4 7因为pivot的结果从列创建了一个索引用作行标签我们可以使用reset_index将数据移回列
In [163]: reshaped.reset_index()
Out[163]:
variable key A B C
0 bar 2 5 8
1 baz 3 6 9
2 foo 1 4 7你还可以指定列的子集作为值的列
In [164]: pd.melt(df, id_vars[key], value_vars[A, B])
Out[164]: key variable value
0 foo A 1
1 bar A 2
2 baz A 3
3 foo B 4
4 bar B 5
5 baz B 6pandas.melt也可以不用分组指标
In [165]: pd.melt(df, value_vars[A, B, C])
Out[165]: variable value
0 A 1
1 A 2
2 A 3
3 B 4
4 B 5
5 B 6
6 C 7
7 C 8
8 C 9In [166]: pd.melt(df, value_vars[key, A, B])
Out[166]: variable value
0 key foo
1 key bar
2 key baz
3 A 1
4 A 2
5 A 3
6 B 4
7 B 5
8 B 6
