Python for Data Analysis v2 | Notes_ Chapter_8 数据规整:聚合、合并和重塑

版权声明:本文为博主--ZJ--原创文章,未经博主允许不得转载。 https://blog.csdn.net/JUNJUN_ZHAO/article/details/80117826

本人以简书作者 SeanCheney 系列专题文章并结合原书为学习资源,记录个人笔记,仅作为知识记录及后期复习所用,原作者地址查看 简书 SeanCheney,如有错误,还望批评指教。——ZJ

原作者:SeanCheney | 《利用 Python 进行数据分析·第2版》第8章 数据规整:聚合、合并和重塑 | 來源:简书

Github:wesm | Github:中文 BrambleXu|
简书:利用 Python 进行数据分析·第2版

环境: Python 3.6


Chapter 8 数据规整:聚合、合并和重塑

在许多应用中,数据可能分散在许多文件或数据库中,存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。

首先,我会介绍 pandas 的层次化索引,它广泛用于以上操作。然后,我深入介绍了一些特殊的数据操作。在第 14 章,你可以看到这些工具的多种应用。

8.1 层次化索引

层次化索引(hierarchical indexing)是 pandas 的一项重要功能,它使你能在一个轴上拥有多个(两个以上)索引级别。抽象点说,它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子:创建一个 Series,并用一个由列表或数组组成的列表作为索引:

In [3]: 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 [4]: data
Out[4]:
a  1    0.519274
   2    1.593852
   3   -0.627557
b  1   -0.022029
   3   -0.684012
c  1    0.101001
   2    0.146661
d  2    0.013020
   3    1.687800
dtype: float64

看到的结果是经过美化的带有 MultiIndex 索引的 Series 的格式。索引之间的“间隔”表示“直接使用上面的标签”:

In [5]: data.index
Out[5]:
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 [7]: data['c']
Out[7]:
1    0.101001
2    0.146661
dtype: float64

In [8]: data['c':'a']
Out[8]: Series([], dtype: float64)

In [9]: data['b':'d']
Out[9]:
b  1   -0.022029
   3   -0.684012
c  1    0.101001
   2    0.146661
d  2    0.013020
   3    1.687800
dtype: float64

In [10]: data.loc[['b', 'c']]
Out[10]:
b  1   -0.022029
   3   -0.684012
c  1    0.101001
   2    0.146661
dtype: float64

In [11]: data.loc[['a', 'd']]
Out[11]:
a  1    0.519274
   2    1.593852
   3   -0.627557
d  2    0.013020
   3    1.687800
dtype: float64

有时甚至还可以在“内层”中进行选取:

In [12]: data[:, 2]
Out[12]:
a    1.593852
c    0.146661
d    0.013020
dtype: float64

In [13]: data['a',2]
Out[13]: 1.5938517892256658

层次化索引在数据重塑和基于分组的操作(如透视表生成)中扮演着重要的角色。例如,可以通过 unstack 方法将这段数据重新安排到一个 DataFrame 中:

In [14]: data.unstack()
Out[14]:
          1         2         3
a  0.519274  1.593852 -0.627557
b -0.022029       NaN -0.684012
c  0.101001  0.146661       NaN
d       NaN  0.013020  1.687800


unstack 的逆运算是stack:

In [15]: data.unstack().stack()
Out[15]:
a  1    0.519274
   2    1.593852
   3   -0.627557
b  1   -0.022029
   3   -0.684012
c  1    0.101001
   2    0.146661
d  2    0.013020
   3    1.687800
dtype: float64


In [16]: data.unstack().unstack()
Out[16]:
1  a    0.519274
   b   -0.022029
   c    0.101001
   d         NaN
2  a    1.593852
   b         NaN
   c    0.146661
   d    0.013020
3  a   -0.627557
   b   -0.684012
   c         NaN
   d    1.687800
dtype: float64

In [17]: data.unstack().unstack().unstack()
Out[17]:
          a         b         c        d
1  0.519274 -0.022029  0.101001      NaN
2  1.593852       NaN  0.146661  0.01302
3 -0.627557 -0.684012       NaN  1.68780

stack 和 unstack 将在本章后面详细讲解。

对于一个 DataFrame ,每条轴都可以有分层索引:

In [21]: frame = pd.DataFrame(np.arange(12).reshape((4, 3)),
    ...:    ....:                      index=[['a', 'a', 'b', 'b'], [1,
    ...:  2, 1, 2]],
    ...:    ....:                      columns=[['Ohio', 'Ohio', 'Color
    ...: ado'],
    ...:    ....:                               ['Green', 'Red', 'Green
    ...: ']])
    ...:

In [22]: frame
Out[22]:
     Ohio     Colorado
    Green Red    Green
a 1     0   1        2
  2     3   4        5
b 1     6   7        8
  2     9  10       11

# 第一列 a, b 是索引 ,第二列  1,2,1,2 也是索引  后三列是数据
# 列名 和行名一样, ohio 上面显示的 代表 第一列 和第二列都是 Ohio ,第三列是 Colorado

In [23]: np.arange(12).reshape((4,3))
Out[23]:
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

In [24]: frame.index
Out[24]:
MultiIndex(levels=[['a', 'b'], [1, 2]],
           labels=[[0, 0, 1, 1], [0, 1, 0, 1]])

各层都可以有名字(可以是字符串,也可以是别的 Python 对象)。如果指定了名称,它们就会显示在控制台输出中:

In [28]: frame.index.names = ['key1', 'key2']

In [29]: frame.columns.names = ['state', 'color']

In [30]: frame
Out[30]:
state      Ohio     Colorado
color     Green Red    Green
key1 key2
a    1        0   1        2
     2        3   4        5
b    1        6   7        8
     2        9  10       11

In [31]: frame.unstack()
Out[31]:
state  Ohio            Colorado
color Green    Red        Green
key2      1  2   1   2        1   2
key1
a         0  3   1   4        2   5
b         6  9   7  10        8  11

In [32]: frame.unstack().stack()
Out[32]:
state     Colorado  Ohio
color        Green Green Red
key1 key2
a    1           2     0   1
     2           5     3   4
b    1           8     6   7
     2          11     9  10

注意:小心区分索引名 state、color 与行标签。

有了部分列索引,因此可以轻松选取列分组:

In [36]: frame['Ohio']
Out[36]:
color      Green  Red
key1 key2
a    1         0    1
     2         3    4
b    1         6    7
     2         9   10

In [37]: frame['Ohio', 'Green']
Out[37]:
key1  key2
a     1       0
      2       3
b     1       6
      2       9
Name: (Ohio, Green), dtype: int32

可以单独创建 MultiIndex 然后复用。上面那个 DataFrame 中的(带有分级名称)列可以这样创建:


In [41]: pd.MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Gre
    ...: en', 'Red', 'Green']], names=['state','color'])
Out[41]:
MultiIndex(levels=[['Colorado', 'Ohio'], ['Green', 'Red']],
           labels=[[1, 1, 0], [0, 1, 0]],
           names=['state', 'color'])

重排与分级排序

有时,你需要重新调整某条轴上各级别的顺序,或根据指定级别上的值对数据进行排序。swaplevel 接受两个级别编号或名称,并返回一个互换了级别的新对象(但数据不会发生变化):

In [42]: frame.swaplevel('key1','key2')
Out[42]:
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 [45]: frame.sort_index(level=1)
Out[45]:
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       11

In [46]: frame.swaplevel(0,1)
Out[46]:
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

In [47]: frame.swaplevel(0,1).sort_index(level=0)
Out[47]:
state      Ohio     Colorado
color     Green Red    Green
key2 key1
1    a        0   1        2
     b        6   7        8
2    a        3   4        5
     b        9  10       11

根据级别汇总统计

许多对 DataFrame 和 Series 的描述和汇总统计都有一个 level 选项,它用于指定在某条轴上求和的级别。再以上面那个 DataFrame 为例,我们可以根据行或列上的级别来进行求和:

In [55]: frame.sum(level='key2')
Out[55]:
state  Ohio     Colorado
color Green Red    Green
key2
1         6   8       10
2        12  14       16

In [56]: frame.sum(level='color', axis=1)
Out[56]:
color      Green  Red
key1 key2
a    1         2    1
     2         8    4
b    1        14    7
     2        20   10

这其实是利用了 pandas 的 groupby 功能,本书稍后将对其进行详细讲解。

使用 DataFrame 的列进行索引

人们经常想要将 DataFrame 的一个或多个列当做行索引来用,或者可能希望将行索引变成 DataFrame 的列。以下面这个 DataFrame 为例:

In [57]: frame = pd.DataFrame({'a':range(7), 'b':range(7,0,-1),'c':['on
    ...: e', 'one', 'one', 'two', 'two',
    ...:    ....:                             'two', 'two'],
    ...:    ....:                       'd': [0, 1, 2, 0, 1, 2, 3]})
    ...:

In [58]: frame
Out[58]:
   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 的 set_index 函数会将其一个或多个列转换为行索引,并创建一个新的 DataFrame :

In [60]: frame2 = frame.set_index(['c', 'd'])

In [61]: frame2
Out[61]:
       a  b
c   d
one 0  0  7
    1  1  6
    2  2  5
two 0  3  4
    1  4  3
    2  5  2
    3  6  1

In [62]: frame2.unstack()
Out[62]:
       a                   b
d      0    1    2    3    0    1    2    3
c
one  0.0  1.0  2.0  NaN  7.0  6.0  5.0  NaN
two  3.0  4.0  5.0  6.0  4.0  3.0  2.0  1.0

默认情况下,那些列会从 DataFrame 中移除,但也可以将其保留下来:

In [63]: frame.set_index(['c', 'd'], drop=False)
Out[63]:
       a  b    c  d
c   d
one 0  0  7  one  0
    1  1  6  one  1
    2  2  5  one  2
two 0  3  4  two  0
    1  4  3  two  1
    2  5  2  two  2
    3  6  1  two  3

reset_index 的功能跟 set_index 刚好相反,层次化索引的级别会被转移到列里面:

In [64]: frame2
Out[64]:
       a  b
c   d
one 0  0  7
    1  1  6
    2  2  5
two 0  3  4
    1  4  3
    2  5  2
    3  6  1

In [65]: frame2.reset_index()
Out[65]:
     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

8.2 合并数据集

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   b

In [38]: df2
Out[38]: 
   data2 key
0      0   a
1      1   b
2      2   d

这是一种多对一的合并。df1 中的数据有多个被标记为 a 和 b 的行,而 df2 中 key 列的每个值则仅对应一行。对这些对象调用 merge 即可得到:

In [70]: pd.merge(df1, df2)
Out[70]:
   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

# 第 一列的索引, 先不用管,然后以 key 列为准,b,b,b,a,a,a 的顺序 调整其他列的顺序

注意,我并没有指明要用哪个列进行连接。如果没有指定,merge 就会将重叠列的列名当做键。不过,最好明确指定一下:

In [71]: pd.merge(df1, df2, on='key')
Out[71]:
   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 [72]: df3 = pd.DataFrame({'lkey':['b', 'b', 'a', 'c', 'a', 'a', 'b']
    ...: ,'data1':range(7)})

In [73]: df4 = pd.DataFrame({'rkey':['a','b','d'],'data2':range(3)})

In [74]: pd.merge(df3, df4, left_on='lkey', right_on='rkey')
Out[74]:
   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

In [75]: df3
Out[75]:
   data1 lkey
0      0    b
1      1    b
2      2    a
3      3    c
4      4    a
5      5    a
6      6    b

In [76]: df4
Out[76]:
   data2 rkey
0      0    a
1      1    b
2      2    d

  • 可能你已经注意到了,结果里面 c 和 d 以及与之相关的数据消失了。默认情况下,merge 做的是“内连接”;结果中的键是交集

  • 其他方式还有”left”、”right”以及”outer”。外连接求取的是键的并集,组合了左连接和右连接的效果:

In [77]: pd.merge(df1, df2, how='outer')
Out[77]:
   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

表8-1对这些选项进行了总结。

这里写图片描述

表8-1 不同的连接类型]

多对多的合并有些不直观。看下面的例子:

In [78]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],'dat
    ...: a1':range(6)})

In [79]: df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],'data2':r
    ...: ange(5)})

In [80]: df1
Out[80]:
   data1 key
0      0   b
1      1   b
2      2   a
3      3   c
4      4   a
5      5   b

In [81]: df2
Out[81]:
   data2 key
0      0   a
1      1   b
2      2   a
3      3   b
4      4   d

In [82]: pd.merge(df1, df2, on='key', how='left')
Out[82]:
    data1 key  data2
0       0   b    1.0
1       0   b    3.0
2       1   b    1.0
3       1   b    3.0
4       2   a    0.0
5       2   a    2.0
6       3   c    NaN
7       4   a    0.0
8       4   a    2.0
9       5   b    1.0
10      5   b    3.0

多对多连接产生的是行的笛卡尔积。由于左边的 DataFrame 有 3 个 “b” 行,右边的有 2 个,所以最终结果中就有 6 个 “b” 行。

理解: 以 b 为例, 就只看前两个

data1  key
  0   b
  1   b

data2  key 
  1   b
  3   b

# 笛卡尔积 2 *2 =4

      data1 key  data2
0       0   b    1.0
1       0   b    3.0
2       1   b    1.0
3       1   b    3.0

连接方式只影响出现在结果中的不同的键的值:

In [83]: pd.merge(df1, df2, how='inner')
Out[83]:
   data1 key  data2
0      0   b      1
1      0   b      3
2      1   b      1
3      1   b      3
4      5   b      1
5      5   b      3
6      2   a      0
7      2   a      2
8      4   a      0
9      4   a      2

要根据多个键进行合并,传入一个由列名组成的列表即可:

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 [88]: left
Out[88]:
  key1 key2  lval
0  foo  one     1
1  foo  two     2
2  bar  one     3

In [89]: right
Out[89]:
  key1 key2  rval
0  foo  one     4
1  foo  one     5
2  bar  one     6
3  bar  two     7


In [53]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
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

结果中会出现哪些键组合取决于所选的合并方式,你可以这样来理解:多个键形成一系列元组,并将其当做单个连接键(当然,实际上并不是这么回事)。

注意:在进行列-列连接时, DataFrame 对象中的索引会被丢弃。

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题(查看前面介绍的重命名轴标签),但 merge 有一个更实用的 suffixes 选项,用于指定附加到左右两个 DataFrame 对象的重叠列名上的字符串:

In [91]: pd.merge(left, right, on='key1')
Out[91]:
  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     7

In [92]: left
Out[92]:
  key1 key2  lval
0  foo  one     1
1  foo  two     2
2  bar  one     3

In [93]: right
Out[93]:
  key1 key2  rval
0  foo  one     4
1  foo  one     5
2  bar  one     6
3  bar  two     7

# key2 的列明是重复的,默认合并后在末尾添加的是 _x ,_y

# 指定添加 后缀

In [94]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
    ...:
Out[94]:
  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

merge 的参数请参见表 8-2。使用 DataFrame 的行索引合并是下一节的主题。

表8-2 merge 函数的参数

这里写图片描述

这里写图片描述

indicator 添加特殊的列 _merge,它可以指明每个行的来源,它的值有 left_only、right_only 或 both,根据每行的合并数据的来源。

索引上的合并

有时候, DataFrame 中的连接键位于其索引中。在这种情况下,你可以传入 left_index=Trueright_index=True(或两个都传)以说明索引应该被用作连接键:

In [95]: left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],'v
    ...: alue':range(6)})

In [96]: right1 = pd.DataFrame({'group_val':[3.5, 7]}, index=['a', 'b']
    ...: )

In [97]: left1
Out[97]:
  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5

In [98]: right1
Out[98]:
   group_val
a        3.5
b        7.0

In [99]: pd.merge(left1, right1, left_on='key', right_index=True)
Out[99]:
  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 [101]: pd.merge(left1, right1, left_on='key', right_index=True, how=
     ...: 'outer')
Out[101]:
  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        NaN

对于层次化索引的数据,事情就有点复杂了,因为索引的合并默认是多键合并:

In [103]: lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio',
     ...:    ....:                                'Nevada', 'Nevada'],
     ...:    ....:                       'key2': [2000, 2001, 2002, 200
     ...: 1, 2002],
     ...:    ....:                       'data': np.arange(5.)})
     ...:

In [104]: righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
     ...:    ....:                       index=[['Nevada', 'Nevada', 'O
     ...: hio', 'Ohio',
     ...:    ....:                               'Ohio', 'Ohio'],
     ...:    ....:                              [2001, 2000, 2000, 2000
     ...: , 2001, 2002]],
     ...:    ....:                       columns=['event1', 'event2'])
     ...:
     ...:

In [105]:

In [105]: lefth
Out[105]:
   data    key1  key2
0   0.0    Ohio  2000
1   1.0    Ohio  2001
2   2.0    Ohio  2002
3   3.0  Nevada  2001
4   4.0  Nevada  2002

In [106]: righth
Out[106]:
             event1  event2
Nevada 2001       0       1
       2000       2       3
Ohio   2000       4       5
       2000       6       7
       2001       8       9
       2002      10      11

这种情况下,你必须以列表的形式指明用作合并键的多个列(注意用how=’outer’对重复索引值的处理):

In [107]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index
     ...: =True)
Out[107]:
   data    key1  key2  event1  event2
0   0.0    Ohio  2000       4       5
0   0.0    Ohio  2000       6       7
1   1.0    Ohio  2001       8       9
2   2.0    Ohio  2002      10      11
3   3.0  Nevada  2001       0       1

In [108]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index
     ...: =True, how='outer')
Out[108]:
   data    key1  key2  event1  event2
0   0.0    Ohio  2000     4.0     5.0
0   0.0    Ohio  2000     6.0     7.0
1   1.0    Ohio  2001     8.0     9.0
2   2.0    Ohio  2002    10.0    11.0
3   3.0  Nevada  2001     0.0     1.0
4   4.0  Nevada  2002     NaN     NaN
4   NaN  Nevada  2000     2.0     3.0


同时使用合并双方的索引也没问题:

In [109]: left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]], index =
     ...: ['a', 'c', 'e'], columns=['Ohio', 'Nevada'])

In [110]: right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 1
     ...: 4]], index=['b', 'c', 'd', 'e'], columns=['Missouri', 'Alabam
     ...: a'])

In [111]: left2
Out[111]:
   Ohio  Nevada
a   1.0     2.0
c   3.0     4.0
e   5.0     6.0


In [113]: right2
Out[113]:
   Missouri  Alabama
b       7.0      8.0
c       9.0     10.0
d      11.0     12.0

In [115]: pd.merge(left2, right2, how='outer', left_index=True, right_i
     ...: ndex=True)
Out[115]:
   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

DataFrame 还有一个便捷的 join 实例方法,它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的 DataFrame 对象,但要求没有重叠的列。在上面那个例子中,我们可以编写:

In [116]: left2.join(right2, how='outer')
Out[116]:
   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

因为一些历史版本的遗留原因, DataFrame 的join方法默认使用的是左连接,保留左边表的行索引。它还支持在调用的 DataFrame 的列上,连接传递的 DataFrame 索引:

In [117]: left1.join(right1, on='key')
Out[117]:
  key  value  group_val
0   a      0        3.5
1   b      1        7.0
2   a      2        3.5
3   a      3        3.5
4   b      4        7.0
5   c      5        NaN

最后,对于简单的索引合并,你还可以向join传入一组 DataFrame ,下一节会介绍更为通用的concat函数,也能实现此功能:

In [119]: another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16.
     ...: , 17.]],
     ...:    ....:                        index=['a', 'c', 'e', 'f'],
     ...:    ....:                        columns=['New York',
     ...: 'Oregon'])
     ...:

In [120]: another
Out[120]:
   New York  Oregon
a       7.0     8.0
c       9.0    10.0
e      11.0    12.0
f      16.0    17.0

In [121]: left2.join([right2, another])
Out[121]:
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a   1.0     2.0       NaN      NaN       7.0     8.0
c   3.0     4.0       9.0     10.0       9.0    10.0
e   5.0     6.0      13.0     14.0      11.0    12.0

In [122]: left2.join([right2, another], how='outer')
Out[122]:
   Ohio  Nevada  Missouri  Alabama  New York  Oregon
a   1.0     2.0       NaN      NaN       7.0     8.0
b   NaN     NaN       7.0      8.0       NaN     NaN
c   3.0     4.0       9.0     10.0       9.0    10.0
d   NaN     NaN      11.0     12.0       NaN     NaN
e   5.0     6.0      13.0     14.0      11.0    12.0
f   NaN     NaN       NaN      NaN      16.0    17.0

轴向连接

另一种数据合并运算也被称作连接(concatenation)、绑定(binding)或堆叠(stacking)。NumPy 的 concatenation 函数可以用 NumPy 数组来做:

In [123]: arr = np.arange(12).reshape((3,4))

In [124]: arr
Out[124]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [125]: np.concatenate([arr,arr], axis=1)
Out[125]:
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 [126]: s1 = pd.Series([0, 1], index=['a', 'b'])

In [127]: s2 = pd.Series([2,3,4], index=['c', 'd', 'e'])

In [128]: s3 = pd.Series([5, 6], index=['f', 'g'])

对这些对象调用 concat 可以将值和索引粘合在一起:

In [129]: s1
Out[129]:
a    0
b    1
dtype: int64

In [130]: s2
Out[130]:
c    2
d    3
e    4
dtype: int64

In [131]: s3
Out[131]:
f    5
g    6
dtype: int64

In [132]: pd.concat([s1, s2, s3])
Out[132]:
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64

默认情况下,concat是在axis=0上工作的,最终产生一个新的Series。如果传入axis=1,则结果就会变成一个 DataFrame (axis=1 是列):

In [133]: pd.concat([s1, s2, s3], axis=1)
Out[133]:
     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=’inner’ 即可得到它们的交集:

In [134]: s4 = pd.concat([s1, s3])

In [135]: s4
Out[135]:
a    0
b    1
f    5
g    6
dtype: int64

In [136]: pd.concat([s3, s4], axis=1)
Out[136]:
     0  1
a  NaN  0
b  NaN  1
f  5.0  5
g  6.0  6

# 第一列 是 s3 的数据,第二列 是 s4 的数据

In [137]: s3
Out[137]:
f    5
g    6
dtype: int64

# s1 s4 的交集

In [138]: pd.concat([s1, s4], axis=1, join='inner')
Out[138]:
   0  1
a  0  0
b  1  1

In [139]: s1
Out[139]:
a    0
b    1
dtype: int64

在这个例子中,f 和 g 标签消失了,是因为使用的是 join=’inner’ 选项。

你可以通过 join_axes 指定要在其它轴上使用的索引:

In [140]: pd.concat([s1, s4], axis=1, join_axes=[['a','c','b', 'e']])
Out[140]:
     0    1
a  0.0  0.0
c  NaN  NaN
b  1.0  1.0
e  NaN  NaN

不过有个问题,参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用 keys 参数即可达到这个目的:

In [142]: result = pd.concat([s1, s2, s3], keys=['one', 'two','three'])
     ...:

In [143]: result
Out[143]:
one    a    0
       b    1
two    c    2
       d    3
       e    4
three  f    5
       g    6
dtype: int64

In [144]: result.unstack()
Out[144]:
         a    b    c    d    e     f    g
one    0.0  1.0  NaN  NaN  NaN  NaN  NaN
two    NaN  NaN  2.0  3.0  4.0  NaN  NaN
three  NaN  NaN  NaN  NaN  NaN  5.0  6.0

如果沿着 axis=1 对 Series 进行合并,则 keys 就会成为 DataFrame 的列头:

In [152]: pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
Out[152]:
   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

同样的逻辑也适用于 DataFrame 对象:


In [145]: df1 = pd.DataFrame(np.arange(6).reshape(3,2), index=['a', 'b'
     ...: , 'c'],columns=['one', 'two'])

In [147]: df2 = pd.DataFrame(5 + np.arange(4).reshape(2,2), index=['a',
     ...: 'c'], columns=['three', 'four'])

In [148]: df1
Out[148]:
   one  two
a    0    1
b    2    3
c    4    5

In [149]: df2
Out[149]:
   three  four
a      5     6
c      7     8

In [150]: pd.concat([df1, df2], axis=1, keys=['level1','level2'])
Out[150]:
  level1     level2
     one two  three four
a      0   1    5.0  6.0
b      2   3    NaN  NaN
c      4   5    7.0  8.0

如果传入的不是列表而是一个字典,则字典的键就会被当做 keys 选项的值:

In [153]: pd.concat({'level':df1, 'level2': df2}, axis=1)
Out[153]:
  level     level2
    one two  three four
a     0   1    5.0  6.0
b     2   3    NaN  NaN
c     4   5    7.0  8.0

此外还有两个用于管理层次化索引创建方式的参数(参见表8-3)。举个例子,我们可以用 names 参数命名创建的轴级别:

In [154]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],names
     ...: =['upper', 'lower'])
Out[154]:
upper level1     level2
lower    one two  three four
a          0   1    5.0  6.0
b          2   3    NaN  NaN
c          4   5    7.0  8.0

最后一个关于 DataFrame 的问题是, DataFrame 的行索引不包含任何相关数据:

In [155]:  df1 = pd.DataFrame(np.random.randn(3,4), columns=['a','b','c
     ...: ','d'])

In [156]: df2 = pd.DataFrame(np.random.randn(2,3), columns=['b', 'd', '
     ...: a'])

In [157]: df1
Out[157]:
          a         b         c         d
0  0.830983 -1.507726  0.522686 -0.640847
1 -0.647306  0.028235  0.358099 -1.179401
2 -1.321904  0.986079  0.486219  0.061789

In [158]: df2
Out[158]:
          b         d         a
0  0.071584  0.172593  0.849266
1  0.677618  0.680149  0.825373

在这种情况下,传入 ignore_index=True 即可:

In [159]: pd.concat([df1, df2], ignore_index=True)
Out[159]:
          a         b         c         d
0  0.830983 -1.507726  0.522686 -0.640847
1 -0.647306  0.028235  0.358099 -1.179401
2 -1.321904  0.986079  0.486219  0.061789
3  0.849266  0.071584       NaN  0.172593
4  0.825373  0.677618       NaN  0.680149

这里写图片描述

合并重叠数据

还有一种数据组合问题不能用简单的合并(merge)或连接(concatenation)运算来处理。比如说,你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子,我们使用 NumPy 的 where 函数,它表示一种等价于面向数组的 if-else:

In [4]: a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan], index=['
   ...: f', 'e', 'd', 'c', 'b', 'a'])

In [6]: b = pd.Series(np.arange(len(a), dtype=np.float64), index = ['f'
   ...: , 'e', 'd', 'c', 'b', 'a'])

In [7]: a
Out[7]:
f    NaN
e    2.5
d    NaN
c    3.5
b    4.5
a    NaN
dtype: float64

In [8]: b
Out[8]:
f    0.0
e    1.0
d    2.0
c    3.0
b    4.0
a    5.0
dtype: float64

In [9]: b[-1]
Out[9]: 5.0

In [10]: b[-1] = np.nan

In [13]: b
Out[13]:
f    0.0
e    1.0
d    2.0
c    3.0
b    4.0
a    NaN
dtype: float64

In [11]: pd.isnull(a)
Out[11]:
f     True
e    False
d     True
c    False
b    False
a     True
dtype: bool

In [12]: np.where(pd.isnull(a), b, a)
Out[12]: array([0. , 2.5, 2. , 3.5, 4.5, nan])

# 相当于 if -else 伪代码

if pd.isnull(a): # 返回的值为 True
    b # 从 b 中提取值
else:
    a # 从 a 中提取值

Series 有一个 combine_first 方法,实现的也是一样的功能,还带有 pandas 的数据对齐:

In [16]: b[:-2].combine_first(a[2:])
Out[16]:
a    NaN
b    4.5
c    3.0
d    2.0
e    1.0
f    0.0
dtype: float64

In [17]: b[:-2]
Out[17]:
f    0.0
e    1.0
d    2.0
c    3.0
dtype: float64

In [18]: a[2:]
Out[18]:
d    NaN
c    3.5
b    4.5
a    NaN
dtype: float64

对于 DataFrame ,combine_first自然也会在列上做同样的事情,因此你可以将其看做:用传递对象中的数据为调用对象的缺失数据“打补丁”:

In [20]: df1 = pd.DataFrame({'a':[1., np.nan, 5., np.nan],'b':[np.nan,
    ...: 2., np.nan, 6.], 'c':range(2, 18, 4)})

In [21]: df2 = pd.DataFrame({'a':[5., 4., np.nan, 3., 7.],'b':[np.nan,
    ...: 3., 4., 6., 8.]})

In [22]: df1
Out[22]:
     a    b   c
0  1.0  NaN   2
1  NaN  2.0   6
2  5.0  NaN  10
3  NaN  6.0  14

In [23]: df2
Out[23]:
     a    b
0  5.0  NaN
1  4.0  3.0
2  NaN  4.0
3  3.0  6.0
4  7.0  8.0

In [24]: df1.combine_first(df2)
Out[24]:
     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

8.3 重塑和轴向旋转

有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑(reshape)或轴向旋转(pivot)运算。

重塑层次化索引

层次化索引为 DataFrame 数据的重排任务提供了一种具有良好一致性的方式。主要功能有二:

  • stack:将数据的列“旋转”为行。
  • unstack :将数据的行“旋转”为列。

我将通过一系列的范例来讲解这些操作。接下来看一个简单的 DataFrame ,其中的行列索引均为字符串数组:

In [25]: data = pd.DataFrame(np.arange(6).reshape((2,3)), index = pd.In
    ...: dex(['Ohio','Colorado'], name='state'), columns=pd.Index(['one
    ...: ', 'two', 'three'],name='number'))

In [26]: data
Out[26]:
number    one  two  three
state
Ohio        0    1      2
Colorado    3    4      5

对该数据使用 stack 方法即可将列转换为行,得到一个 Series:

In [27]: result = data.stack()

In [28]: result
Out[28]:
state     number
Ohio      one       0
          two       1
          three     2
Colorado  one       3
          two       4
          three     5
dtype: int32

对于一个层次化索引的Series,你可以用 unstack 将其重排为一个 DataFrame :


In [29]: result.unstack()
Out[29]:
number    one  two  three
state
Ohio        0    1      2
Colorado    3    4      5

默认情况下, unstack 操作的是最内层(stack 也是如此)。传入分层级别的编号或名称即可对其它级别进行 unstack 操作:

In [30]: result.unstack(0)
Out[30]:
state   Ohio  Colorado
number
one        0         3
two        1         4
three      2         5

In [31]: result.unstack('state')
Out[31]:
state   Ohio  Colorado
number
one        0         3
two        1         4
three      2         5

如果不是所有的级别值都能在各分组中找到的话,则 unstack 操作可能会引入缺失数据:

In [36]: s1 = pd.Series([0,1,2,3],index=['a', 'b', 'c', 'd'])

In [37]: s2= pd.Series([4,5,6], index=['c', 'd', 'e'])

In [38]: data2 = pd.concat([s1, s2], keys=['one', 'two'])

In [39]: data2
Out[39]:
one  a    0
     b    1
     c    2
     d    3
two  c    4
     d    5
     e    6
dtype: int64

In [42]: data2.unstack()
Out[42]:
       a    b    c    d    e
one  0.0  1.0  2.0  3.0  NaN
two  NaN  NaN  4.0  5.0  6.0

# s1 中的 index 有 a,b,c,d 但是没有 e ,而 s2 中有 e ,但是没有 a,b 所以各自之间连接后 有缺失值

stack 默认会滤除缺失数据,因此该运算是可逆的:

In [43]: data2.unstack()
Out[43]:
       a    b    c    d    e
one  0.0  1.0  2.0  3.0  NaN
two  NaN  NaN  4.0  5.0  6.0

In [44]: data2.unstack().stack()
Out[44]:
one  a    0.0
     b    1.0
     c    2.0
     d    3.0
two  c    4.0
     d    5.0
     e    6.0
dtype: float64

In [45]: data2.unstack().stack(dropna=False)
Out[45]:
one  a    0.0
     b    1.0
     c    2.0
     d    3.0
     e    NaN
two  a    NaN
     b    NaN
     c    4.0
     d    5.0
     e    6.0
dtype: float64

在对 DataFrame 进行 unstack 操作时,作为旋转轴的级别将会成为结果中的最低级别:

In [46]: df = pd.DataFrame({'left':result, 'right': result +5}, columns
    ...: =pd.Index(['left', 'right'], name='side'))

In [47]: df
Out[47]:
side             left  right
state    number
Ohio     one        0      5
         two        1      6
         three      2      7
Colorado one        3      8
         two        4      9
         three      5     10

In [48]: result
Out[48]:
state     number
Ohio      one       0
          two       1
          three     2
Colorado  one       3
          two       4
          three     5
dtype: int32

In [49]: df.unstack('state')
Out[49]:
side   left          right
state  Ohio Colorado  Ohio Colorado
number
one       0        3     5        8
two       1        4     6        9
three     2        5     7       10

当调用 stack,我们可以指明轴的名字:

In [51]: df
Out[51]:
side             left  right
state    number
Ohio     one        0      5
         two        1      6
         three      2      7
Colorado one        3      8
         two        4      9
         three      5     10


In [50]: df.unstack('state').stack('side')
Out[50]:
state         Colorado  Ohio
number side
one    left          3     0
       right         8     5
two    left          4     1
       right         9     6
three  left          5     2
       right        10     7

将“长格式”旋转为“宽格式”

多个时间序列数据通常是以所谓的“长格式”(long)或“堆叠格式”(stacked)存储在数据库和 CSV 中的。我们先加载一些示例数据,做一些时间序列规整和数据清洗:

In [3]: data = pd.read_csv('examples/macrodata.csv')

In [4]: data.head()
Out[4]:
     year  quarter   realgdp  realcons  realinv  realgovt  realdpi    cp
i  \
0  1959.0      1.0  2710.349    1707.4  286.898   470.045   1886.9  28.9
8
1  1959.0      2.0  2778.801    1733.7  310.859   481.301   1919.7  29.1
5
2  1959.0      3.0  2775.488    1751.8  289.226   491.260   1916.4  29.3
5
3  1959.0      4.0  2785.204    1753.7  299.356   484.052   1931.3  29.3
7
4  1960.0      1.0  2847.699    1770.5  331.722   462.199   1955.5  29.5
4

      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 [5]: periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,
   ...: name='date')

In [6]: periods
Out[6]:
PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2',

             '1960Q3', '1960Q4', '1961Q1', '1961Q2',
             ...
             '2007Q2', '2007Q3', '2007Q4', '2008Q1', '2008Q2', '2008Q3',

             '2008Q4', '2009Q1', '2009Q2', '2009Q3'],
            dtype='period[Q-DEC]', name='date', length=203, freq='Q-DEC'
)

In [7]: columns = pd.Index(['realgdp', 'inf1', 'unemp'], name='otem')

In [8]: columns
Out[8]: Index(['realgdp', 'inf1', 'unemp'], dtype='object', name='otem')

In [11]: data = data.reindex(columns=columns)

In [12]: data
Out[12]:
otem    realgdp  inf1  unemp
0      2710.349   NaN    5.8
1      2778.801   NaN    5.1
2      2775.488   NaN    5.3
3      2785.204   NaN    5.6
4      2847.699   NaN    5.2


..          ...   ...    ...

195   13391.249   NaN    4.8
196   13366.865   NaN    4.9
197   13415.266   NaN    5.4
198   13324.600   NaN    6.0
199   13141.920   NaN    6.9
200   12925.410   NaN    8.1
201   12901.504   NaN    9.2
202   12990.341   NaN    9.6

[203 rows x 3 columns]

In [18]: data.index = periods.to_timestamp('D', 'end')
    ...:

In [19]: ldata = data.stack().reset_index().rename(columns={0:'value'})
    ...:

In [20]: ldata
Out[20]:
          date     item      value
0   1959-03-31  realgdp   2710.349
1   1959-03-31    unemp      5.800
2   1959-06-30  realgdp   2778.801
3   1959-06-30    unemp      5.100
4   1959-09-30  realgdp   2775.488
5   1959-09-30    unemp      5.300

..         ...      ...        ...

401 2009-03-31    unemp      8.100
402 2009-06-30  realgdp  12901.504
403 2009-06-30    unemp      9.200
404 2009-09-30  realgdp  12990.341
405 2009-09-30    unemp      9.600

[406 rows x 3 columns]

这就是多个时间序列(或者其它带有两个或多个键的可观察数据,这里,我们的键是date 和 item)的长格式。表中的每行代表一次观察。

关系型数据库(如 MySQL)中的数据经常都是这样存储的,因为固定架构(即列名和数据类型)有一个好处:随着表中数据的添加,item 列中的值的种类能够增加。在前面的例子中,date 和 item 通常就是主键(用关系型数据库的说法),不仅提供了关系完整性,而且提供了更为简单的查询支持。有的情况下,使用这样的数据会很麻烦,你可能会更喜欢 DataFrame ,不同的 item 值分别形成一列,date列中的时间戳则用作索引。 DataFrame 的 pivot方法完全可以实现这个转换:


In [20]: ldata
Out[20]:
          date     item      value
0   1959-03-31  realgdp   2710.349
1   1959-03-31    unemp      5.800
2   1959-06-30  realgdp   2778.801
3   1959-06-30    unemp      5.100
4   1959-09-30  realgdp   2775.488
5   1959-09-30    unemp      5.300

..         ...      ...        ...

401 2009-03-31    unemp      8.100
402 2009-06-30  realgdp  12901.504
403 2009-06-30    unemp      9.200
404 2009-09-30  realgdp  12990.341
405 2009-09-30    unemp      9.600

 In [21]: pivoted = ldata.pivot('date', 'item', 'value')

In [22]: pivoted
Out[22]:
item          realgdp  unemp
date
1959-03-31   2710.349    5.8
1959-06-30   2778.801    5.1
1959-09-30   2775.488    5.3
1959-12-31   2785.204    5.6
1960-03-31   2847.699    5.2
1960-06-30   2834.390    5.2
1960-09-30   2839.022    5.6
1960-12-31   2802.616    6.3
1961-03-31   2819.264    6.8

...               ...    ...

2007-06-30  13203.977    4.5
2007-09-30  13321.109    4.7
2007-12-31  13391.249    4.8
2008-03-31  13366.865    4.9
2008-06-30  13415.266    5.4
2008-09-30  13324.600    6.0
2008-12-31  13141.920    6.9
2009-03-31  12925.410    8.1
2009-06-30  12901.504    9.2
2009-09-30  12990.341    9.6

[203 rows x 2 columns]

前两个传递的值分别用作行和列索引,最后一个可选值则是用于填充 DataFrame 的数据列。假设有两个需要同时重塑的数据列:

In [23]: ldata['value2'] = np.random.randn(len(ldata))

In [24]: ldata[:10]
Out[24]:
        date     item     value    value2
0 1959-03-31  realgdp  2710.349  1.692280
1 1959-03-31    unemp     5.800  0.171287
2 1959-06-30  realgdp  2778.801  0.987641
3 1959-06-30    unemp     5.100  0.978923
4 1959-09-30  realgdp  2775.488  0.005767
5 1959-09-30    unemp     5.300  1.177017
6 1959-12-31  realgdp  2785.204 -1.247027
7 1959-12-31    unemp     5.600 -0.276246
8 1960-03-31  realgdp  2847.699  1.331130
9 1960-03-31    unemp     5.200 -0.405204

如果忽略最后一个参数,得到的 DataFrame 就会带有层次化的列:

In [25]: pivoted = ldata.pivot('date', 'item')

In [26]: pivoted[:5]
Out[26]:
               value          value2
item         realgdp unemp   realgdp     unemp
date
1959-03-31  2710.349   5.8  1.692280  0.171287
1959-06-30  2778.801   5.1  0.987641  0.978923
1959-09-30  2775.488   5.3  0.005767  1.177017
1959-12-31  2785.204   5.6 -1.247027 -0.276246
1960-03-31  2847.699   5.2  1.331130 -0.405204

In [27]: pivoted['value'][:5]
Out[27]:
item         realgdp  unemp
date
1959-03-31  2710.349    5.8
1959-06-30  2778.801    5.1
1959-09-30  2775.488    5.3
1959-12-31  2785.204    5.6
1960-03-31  2847.699    5.2

注意,pivot其实就是用 set_index 创建层次化索引,再用 unstack 重塑:

In [28]: unstacked = ldata.set_index(['date', 'item']).unstack('item')

In [29]: unstacked[:7]
Out[29]:
               value          value2
item         realgdp unemp   realgdp     unemp
date
1959-03-31  2710.349   5.8  1.692280  0.171287
1959-06-30  2778.801   5.1  0.987641  0.978923
1959-09-30  2775.488   5.3  0.005767  1.177017
1959-12-31  2785.204   5.6 -1.247027 -0.276246
1960-03-31  2847.699   5.2  1.331130 -0.405204
1960-06-30  2834.390   5.2  0.998744 -1.381110
1960-09-30  2839.022   5.6  0.022925  1.050719

In [30]: ldata.set_index(['date', 'item'])
Out[30]:
                        value    value2
date       item
1959-03-31 realgdp   2710.349  1.692280
           unemp        5.800  0.171287
1959-06-30 realgdp   2778.801  0.987641
           unemp        5.100  0.978923
1959-09-30 realgdp   2775.488  0.005767
           unemp        5.300  1.177017
1959-12-31 realgdp   2785.204 -1.247027
           unemp        5.600 -0.276246
1960-03-31 realgdp   2847.699  1.331130
           unemp        5.200 -0.405204

...                       ...       ...

           unemp        6.000  0.577148
2008-12-31 realgdp  13141.920 -1.034448
           unemp        6.900  1.232211
2009-03-31 realgdp  12925.410 -1.340544
           unemp        8.100  1.457841
2009-06-30 realgdp  12901.504  1.911584
           unemp        9.200  0.509018
2009-09-30 realgdp  12990.341 -0.520676
           unemp        9.600  1.106940

[406 rows x 2 columns]

将“宽格式”旋转为“长格式”

旋转 DataFrame 的逆运算是 pandas.melt。它不是将一列转换到多个新的 DataFrame ,而是合并多个列成为一个,产生一个比输入长的 DataFrame 。看一个例子:

In [32]: df = pd.DataFrame({'key':['foo', 'bar', 'baz'],'A':[1, 2, 3],'
    ...: B':[4, 5, 6], 'C':[7, 8,9]})

In [33]: df
Out[33]:
   A  B  C  key
0  1  4  7  foo
1  2  5  8  bar
2  3  6  9  baz

key 列可能是分组指标,其它的列是数据值。当使用 pandas.melt,我们必须指明哪些列是分组指标。下面使用 key 作为唯一的分组指标:

In [34]: df
Out[34]:
   A  B  C  key
0  1  4  7  foo
1  2  5  8  bar
2  3  6  9  baz

In [35]: melted = pd.melt(df, ['key'])

In [36]: melted
Out[36]:
   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 [37]: reshaped = melted.pivot('key','variable', 'value')

In [38]: reshaped
Out[38]:
variable  A  B  C
key
bar       2  5  8
baz       3  6  9
foo       1  4  7

In [39]: melted
Out[39]:
   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 的结果从列创建了一个索引,用作行标签,我们可以使用 reset_index 将数据移回列:

In [40]: reshaped.reset_index()
Out[40]:
variable  key  A  B  C
0         bar  2  5  8
1         baz  3  6  9
2         foo  1  4  7

你还可以指定列的子集,作为值的列:

In [41]: pd.melt(df, id_vars=['key'], value_vars=['A','B'])
Out[41]:
   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

pandas .melt也可以不用分组指标:

In [42]: pd.melt(df, value_vars=['A','B','C'])
Out[42]:
  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      9

In [43]: pd.melt(df, value_vars=['key','A', 'B'])
Out[43]:
  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

8.4 总结

现在你已经掌握了 pandas 数据导入、清洗、重塑,我们可以进一步学习matplotlib数据可视化。我们在稍后会回到 pandas ,学习更高级的分析。

展开阅读全文

没有更多推荐了,返回首页