合并数据集

pandas对象中的数据可以通过一些内置的方式进行合并：

·pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的连接操作。

·pandas.concat可以沿着一条轴将多个对象堆叠到一起。

·实例方法combine_first可以将重复数据编接在一起，用一个对象中的值填充另一个对象中的缺失值。译注1

我将分别对它们进行讲解，并给出一些例子。本书剩余部分的示例中将经常用到它们。

数据库风格的DataFrame合并

数据集的合并（merge）或连接（join）运算是通过一个或多个键将行链接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点。

我们以一个简单的例子开始：

  1. In [15]: df1 = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
  2.     ...:                  'data1': range(7)})
  3.  
  4. In [16]: df2 = DataFrame({'key': ['a', 'b', 'd'],
  5.     ...:                  'data2': range(3)})
  6.  
  7. In [17]: df1
  8. Out[17]:
  9.    data1 key
  10. 0      0   b
  11. 1      1   b
  12. 2      2   a
  13. 3      3   c
  14. 4      4   a
  15. 5      5   a
  16. 6      6   b
  17. In [18]: df2
  18. Out[18]:
  19.    data2 key
  20. 0      0   a
  21. 1      1   b
  22. 2      2   d

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

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

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

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

如果两个对象的列名不同，也可以分别进行指定：

  1. In [21]: df3 = DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
  2.     ...:                  'data1': range(7)})
  3.  
  4. In [22]: df4 = DataFrame({'rkey': ['a', 'b', 'd'],
  5.     ...:                  'data2': range(3)})
  6.  
  7. In [23]: pd.merge(df3, df4, left_on='lkey', right_on='rkey')
  8. Out[23]:
  9.    data1 lkey  data2 rkey
  10. 0      2    a      0    a
  11. 1      4    a      0    a
  12. 2      5    a      0    a
  13. 3      0    b      1    b
  14. 4      1    b      1    b
  15. 5      6    b      1    b

可能你已经注意到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是"inner"连接；结果中的键是交集。其他方式还有"left"、"right"以及"outer"。外连接求取的是键的并集，组合了左连接和右连接的效果：

  1. In [24]: pd.merge(df1, df2, how='outer')
  2. Out[24]:
  3.    data1 key  data2
  4. 0      2   a      0
  5. 1      4   a      0
  6. 2      5   a      0
  7. 3      0   b      1
  8. 4      1   b      1
  9. 5      6   b      1
  10. 6      3   c    NaN
  11. 7    NaN   d      2

多对多的合并操作非常简单，无需额外的工作。如下所示：

  1. In [25]: df1 = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
  2.     ...:                  'data1': range(6)})
  3.  
  4. In [26]: df2 = DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],
  5.     ...:                  'data2': range(5)})
  6.  
  7. In [27]: df1
  8. Out[27]:
  9.    data1 key
  10. 0      0   b
  11. 1      1   b
  12. 2      2   a
  13. 3      3   c
  14. 4      4   a
  15. 5      5   b
  16. In [28]: df2
  17. Out[28]:
  18.    data2 key
  19. 0      0   a
  20. 1      1   b
  21. 2      2   a
  22. 3      3   b
  23. 4      4   d
  24. In [29]: pd.merge(df1, df2, on='key', how='left')
  25. Out[29]:
  26.     data1 key  data2
  27. 0       2   a      0
  28. 1       2   a      2
  29. 2       4   a      0
  30. 3       4   a      2
  31. 4       0   b      1
  32. 5       0   b      3
  33. 6       1   b      1
  34. 7       1   b      3
  35. 8       5   b      1
  36. 9       5   b      3
  37. 10      3   c    NaN

多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最终结果中就有6个"b"行。连接方式只影响出现在结果中的键：

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

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

  1. In [31]: left = DataFrame({'key1': ['foo', 'foo', 'bar'],
  2.     ...:                   'key2': ['one', 'two', 'one'],
  3.     ...:                   'lval': [1, 2, 3]})
  4.  
  5. In [32]: right = DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
  6.     ...:                    'key2': ['one', 'one', 'one', 'two'],
  7.     ...:                    'rval': [4, 5, 6, 7]})
  8.  
  9. In [33]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
  10. Out[33]:
  11.   key1 key2  lval  rval
  12. 0  bar  one     3     6
  13. 1  bar  two   NaN     7
  14. 2  foo  one     1     4
  15. 3  foo  one     1     5
  16. 4  foo  two     2   NaN

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

警告： 在进行列－列连接时，DataFrame对象中的索引会被丢弃。

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（稍后将会介绍如何重命名轴标签），但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：

  1. In [34]: pd.merge(left, right, on='key1')
  2. Out[34]:
  3.   key1 key2_x  lval key2_y  rval
  4. 0  bar    one     3    one     6
  5. 1  bar    one     3    two     7
  6. 2  foo    one     1    one     4
  7. 3  foo    one     1    one     5
  8. 4  foo    two     2    one     4
  9. 5  foo    two     2    one     5
  10.  
  11. In [35]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
  12. Out[35]:
  13.   key1 key2_left  lval key2_right  rval
  14. 0  bar       one     3        one     6
  15. 1  bar       one     3        two     7
  16. 2  foo       one     1        one     4
  17. 3  foo       one     1        one     5
  18. 4  foo       two     2        one     4
  19. 5  foo       two     2        one     5

merge的参数请参见表7-1。索引上的连接将在下一节中讲解。

合并数据集 - 图1

合并数据集 - 图2

索引上的合并

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

  1. In [36]: left1 = DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
  2.    ....: 'value': range(6)})
  3. In [37]: right1 = DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
  4. In [38]: left1
  5. Out[38]:
  6.   key  value
  7. 0   a      0
  8. 1   b      1
  9. 2   a      2
  10. 3   a      3
  11. 4   b      4
  12. 5   c      5
  13. In [39]: right1
  14. Out[39]:
  15.    group_val
  16. a        3.5
  17. b        7.0
  18.  
  19. In [40]: pd.merge(left1, right1, left_on='key', right_index=True)
  20. Out[40]:
  21.   key  value  group_val
  22. 0   a      0        3.5
  23. 2   a      2        3.5
  24. 3   a      3        3.5
  25. 1   b      1        7.0
  26. 4   b      4        7.0

由于默认的merge方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：

  1. In [41]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
  2. Out[41]:
  3.   key  value  group_val
  4. 0   a      0        3.5
  5. 2   a      2        3.5
  6. 3   a      3        3.5
  7. 1   b      1        7.0
  8. 4   b      4        7.0
  9. 5   c      5        NaN

对于层次化索引的数据，事情就有点复杂了：

  1. In [42]: lefth = DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
  2.     ...:                    'key2': [2000, 2001, 2002, 2001, 2002],
  3.     ...:                    'data': np.arange(5.)})
  4.  
  5. In [43]: righth = DataFrame(np.arange(12).reshape((6, 2)),
  6.     ...:                    index=[['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'],
  7.     ...:                    [2001, 2000, 2000, 2000, 2001, 2002]],
  8.     ...:                    columns=['event1', 'event2'])
  9.  
  10. In [44]: lefth
  11. Out[44]:
  12.    data    key1  key2
  13. 0     0    Ohio  2000
  14. 1     1    Ohio  2001
  15. 2     2    Ohio  2002
  16. 3     3  Nevada  2001
  17. 4     4  Nevada  2002
  18. In [45]: righth
  19. Out[45]:
  20.              event1  event2
  21. Nevada 2001       0       1
  22.        2000       2       3
  23. Ohio   2000       4       5
  24.        2000       6       7
  25.        2001       8       9
  26.        2002      10      11

这种情况下，你必须以列表的形式指明用作合并键的多个列（注意对重复索引值的处理）：

  1. In [46]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
  2. Out[46]:
  3.    data    key1  key2  event1  event2
  4. 3     3  Nevada  2001       0       1
  5. 0     0    Ohio  2000       4       5
  6. 0     0    Ohio  2000       6       7
  7. 1     1    Ohio  2001       8       9
  8. 2     2    Ohio  2002      10      11
  9.  
  10. In [47]: pd.merge(lefth, righth, left_on=['key1', 'key2'],
  11.     ...:          right_index=True, how='outer')
  12. Out[47]:
  13.    data    key1  key2  event1  event2
  14. 4   NaN  Nevada  2000       2       3
  15. 3     3  Nevada  2001       0       1
  16. 4     4  Nevada  2002     NaN     NaN
  17. 0     0    Ohio  2000       4       5
  18. 0     0    Ohio  2000       6       7
  19. 1     1    Ohio  2001       8       9
  20. 2     2    Ohio  2002      10      11

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

  1. In [48]: left2 = DataFrame([[1., 2.], [3., 4.], [5., 6.]], index=['a', 'c', 'e'],
  2.     ...:                   columns=['Ohio', 'Nevada'])
  3.  
  4. In [49]: right2 = DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
  5.     ...:                    index=['b', 'c', 'd', 'e'], columns=['Missouri', 'Alabama'])
  6. In [50]: left2
  7. Out[50]:
  8.    Ohio  Nevada
  9. a     1       2
  10. c     3       4
  11. e     5       6
  12. In [51]: right2
  13. Out[51]:
  14.    Missouri  Alabama
  15. b         7        8
  16. c         9       10
  17. d        11       12
  18. e        13       14
  19.  
  20. In [52]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
  21. Out[52]:
  22.    Ohio  Nevada  Missouri  Alabama
  23. a     1       2       NaN      NaN
  24. b   NaN     NaN         7        8
  25. c     3       4         9       10
  26. d   NaN     NaN        11       12
  27. e     5       6        13       14

DataFrame还有一个join实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，而不管它们之间有没有重叠的列。在上面那个例子中，我们可以编写：

  1. In [53]: left2.join(right2, how='outer')
  2. Out[53]:
  3.    Ohio  Nevada  Missouri  Alabama
  4. a     1       2       NaN      NaN
  5. b   NaN     NaN         7        8
  6. c     3       4         9       10
  7. d   NaN     NaN        11       12
  8. e     5       6        13       14

由于一些历史原因（早期版本的pandas），DataFrame的join方法是在连接键上做左连接。它还支持参数DataFrame的索引跟调用者DataFrame的某个列之间的连接：

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

最后，对于简单的索引合并，你还可以向join传入一组DataFrame（后面我们会介绍更为通用的concat函数，它也能实现此功能）：

  1. In [55]: another = DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
  2.     ...:                     index=['a', 'c', 'e', 'f'], columns=['New York', 'Oregon'])
  3.  
  4. In [56]: left2.join([right2, another])
  5. Out[56]:
  6.    Ohio  Nevada  Missouri  Alabama  New York  Oregon
  7. a     1       2       NaN      NaN         7       8
  8. c     3       4         9       10         9      10
  9. e     5       6        13       14        11      12
  10.  
  11. In [57]: left2.join([right2, another], how='outer')
  12. Out[57]:
  13.    Ohio  Nevada  Missouri  Alabama  New York  Oregon
  14. a     1       2       NaN      NaN         7       8
  15. b   NaN     NaN         7        8       NaN     NaN
  16. c     3       4         9       10         9      10
  17. d   NaN     NaN        11       12       NaN     NaN
  18. e     5       6        13       14        11      12
  19. f   NaN     NaN       NaN      NaN        16      17

轴向连接

另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy有一个用于合并原始NumPy数组的concatenation函数：

  1. In [58]: arr = np.arange(12).reshape((3, 4))
  2.  
  3. In [59]: arr
  4. Out[59]:
  5. array([[ 0,  1,  2,  3],
  6.        [ 4,  5,  6,  7],
  7.        [ 8,  9, 10, 11]])
  8.  
  9. In [60]: np.concatenate([arr, arr], axis=1)
  10. Out[60]:
  11. array([[ 0,  1,  2,  3,  0,  1,  2,  3],
  12.        [ 4,  5,  6,  7,  4,  5,  6,  7],
  13.        [ 8,  9, 10, 11,  8,  9, 10, 11]])

对于pandas对象（如Series和DataFrame），带有标签的轴使你能够进一步推广数组的连接运算。具体点说，你还需要考虑以下这些东西：

·如果各对象其他轴上的索引不同，那些轴应该是做并集还是交集？

·结果对象中的分组需要各不相同吗？

·用于连接的轴重要吗？

pandas的concat函数提供了一种能够解决这些问题的可靠方式。我将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的Series：

  1. In [61]: s1 = Series([0, 1], index=['a', 'b'])
  2.  
  3. In [62]: s2 = Series([2, 3, 4], index=['c', 'd', 'e'])
  4.  
  5. In [63]: s3 = Series([5, 6], index=['f', 'g'])

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

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

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

  1. In [65]: pd.concat([s1, s2, s3], axis=1)
  2. Out[65]:
  3.     0   1   2
  4. a   0 NaN NaN
  5. b   1 NaN NaN
  6. c NaN   2 NaN
  7. d NaN   3 NaN
  8. e NaN   4 NaN
  9. f NaN NaN   5
  10. g NaN NaN   6

这种情况下，另外一条轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入join='inner'即可得到它们的交集：

  1. In [66]: s4 = pd.concat([s1 * 5, s3])
  2.  
  3. In [67]: pd.concat([s1, s4], axis=1) In [68]: pd.concat([s1, s4], axis=1, join='inner')
  4. Out[67]:                             Out[68]:
  5.     0  1                                0  1
  6. a   0  0                             a  0  0
  7. b   1  5                             b  1  5
  8. f NaN  5
  9. g NaN  6

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

  1. In [69]: pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])
  2. Out[69]:
  3.     0   1
  4. a   0   0
  5. c NaN NaN
  6. b   1   5
  7. e NaN NaN

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

  1. In [70]: result = pd.concat([s1, s1, s3], keys=['one', 'two', 'three'])
  2.  
  3. In [71]: result
  4. Out[71]:
  5. one    a    0
  6.        b    1
  7. two    a    0
  8.        b    1
  9. three  f    5
  10.        g    6
  11.  
  12. # 稍后将详细讲解unstack函数
  13. In [72]: result.unstack()
  14. Out[72]:
  15.         a   b   f   g
  16. one     0   1 NaN NaN
  17. two     0   1 NaN NaN
  18. three NaN NaN   5   6

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

  1. In [73]: pd.concat([s1, s2, s3], axis=1, keys=['one', 'two', 'three'])
  2. Out[73]:
  3.    one  two  three
  4. a    0  NaN    NaN
  5. b    1  NaN    NaN
  6. c  NaN    2    NaN
  7. d  NaN    3    NaN
  8. e  NaN    4    NaN
  9. f  NaN  NaN      5
  10. g  NaN  NaN      6

同样的逻辑对DataFrame对象也是一样：

  1. In [74]: df1 = DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
  2.     ...:                 columns=['one', 'two'])
  3.  
  4. In [75]: df2 = DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
  5.     ...:                 columns=['three', 'four'])
  6.  
  7. In [76]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
  8. Out[76]:
  9.    level1       level2
  10.       one  two   three  four
  11. a       0    1       5     6
  12. b       2    3     NaN   NaN
  13. c       4    5       7     8

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

  1. In [77]: pd.concat({'level1': df1, 'level2': df2}, axis=1)
  2. Out[77]:
  3.    level1       level2
  4.       one  two   three  four
  5. a       0    1       5     6
  6. b       2    3     NaN   NaN
  7. c       4    5       7     8

此外还有两个用于管理层次化索引创建方式的参数（参见表7-2）：

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

最后一个需要考虑的问题是，跟当前分析工作无关的DataFrame行索引译注2：

  1. In [79]: df1 = DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
  2.  
  3. In [80]: df2 = DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
  4. In [81]: df1
  5. Out[81]:
  6.           a         b         c         d
  7. 0 -0.204708  0.478943 -0.519439 -0.555730
  8. 1  1.965781  1.393406  0.092908  0.281746
  9. 2  0.769023  1.246435  1.007189 -1.296221
  10. In [82]: df2
  11. Out[82]:
  12.           b         d         a
  13. 0  0.274992  0.228913  1.352917
  14. 1  0.886429 -2.001637 -0.371843

在这种情况下，传入ignore_index=True即可：

  1. In [83]: pd.concat([df1, df2], ignore_index=True)
  2. Out[83]:
  3.           a         b         c         d
  4. 0 -0.204708  0.478943 -0.519439 -0.555730
  5. 1  1.965781  1.393406  0.092908  0.281746
  6. 2  0.769023  1.246435  1.007189 -1.296221
  7. 3  1.352917  0.274992       NaN  0.228913
  8. 4 -0.371843  0.886429       NaN -2.001637

合并数据集 - 图3

译注3：就是外层级别的索引。

合并重叠数据

还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。给这个例子增加一点启发性，我们使用NumPy的where函数，它用于表达一种矢量化的if-else：

  1. In [84]: a = Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
  2.     ...:            index=['f', 'e', 'd', 'c', 'b', 'a'])
  3.  
  4. In [85]: b = Series(np.arange(len(a), dtype=np.float64),
  5.     ...:            index=['f', 'e', 'd', 'c', 'b', 'a'])
  6.  
  7. In [86]: b[-1] = np.nan
  8.  
  9. In [87]: a            In [88]: b       In [89]: np.where(pd.isnull(a), b, a)
  10. Out[87]:              Out[88]:         Out[89]:
  11. f    NaN              f     0          f    0.0
  12. e    2.5              e     1          e    2.5
  13. d    NaN              d     2          d    2.0
  14. c    3.5              c     3          c    3.5
  15. b    4.5              b     4          b    4.5
  16. a    NaN              a   NaN          a    NaN

Series有一个combine_first方法，实现的也是一样的功能，而且会进行数据对齐：

  1. In [90]: b[:-2].combine_first(a[2:])
  2. Out[90]:
  3. a    NaN
  4. b    4.5
  5. c    3.0
  6. d    2.0
  7. e    1.0
  8. f    0.0

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

  1. In [91]: df1 = DataFrame({'a': [1., np.nan, 5., np.nan],
  2.     ...:                  'b': [np.nan, 2., np.nan, 6.],
  3.     ...:                  'c': range(2, 18, 4)})
  4.  
  5. In [92]: df2 = DataFrame({'a': [5., 4., np.nan, 3., 7.],
  6.     ...:                  'b': [np.nan, 3., 4., 6., 8.]})
  7.  
  8. In [93]: df1.combine_first(df2)
  9. Out[93]:
  10.    a   b   c
  11. 0  1 NaN   2
  12. 1  4   2   6
  13. 2  5   4  10
  14. 3  3   6  14
  15. 4  7   8 NaN

译注1：通俗来说，差不多就是数据库的全外连接（注意“差不多”和“全外连接”这两个词）。简单地说，就是先从第一个对象中选值，不行就再去第二个对象中选值。

译注2：也就是说那些行索引是无意义的。