• 8.2 合并数据集
    • 数据库风格的DataFrame合并
    • 索引上的合并
    • 轴向连接
    • 合并重叠数据

    8.2 合并数据集

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

    • pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉,因为它实现的就是数据库的join操作。
    • pandas.concat可以沿着一条轴将多个对象堆叠到一起。
    • 实例方法combine_first可以将重复数据拼接在一起,用一个对象中的值填充另一个对象中的缺失值。

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

    数据库风格的DataFrame合并

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

    以一个简单的例子开始:

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

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

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

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

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

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

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

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

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

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

    表8-1 不同的连接类型

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

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

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

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

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

    1. In [51]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
    2. ....: 'key2': ['one', 'two', 'one'],
    3. ....: 'lval': [1, 2, 3]})
    4. In [52]: right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
    5. ....: 'key2': ['one', 'one', 'one', 'two'],
    6. ....: 'rval': [4, 5, 6, 7]})
    7. In [53]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
    8. Out[53]:
    9. key1 key2 lval rval
    10. 0 foo one 1.0 4.0
    11. 1 foo one 1.0 5.0
    12. 2 foo two 2.0 NaN
    13. 3 bar one 3.0 6.0
    14. 4 bar two NaN 7.0

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

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

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

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

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

    表8-2 merge函数的参数

    8.2 合并数据集 - 图2

    8.2 合并数据集 - 图3

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

    索引上的合并

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

    1. In [56]: left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
    2. ....: 'value': range(6)})
    3. In [57]: right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
    4. In [58]: left1
    5. Out[58]:
    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 [59]: right1
    14. Out[59]:
    15. group_val
    16. a 3.5
    17. b 7.0
    18. In [60]: pd.merge(left1, right1, left_on='key', right_index=True)
    19. Out[60]:
    20. key value group_val
    21. 0 a 0 3.5
    22. 2 a 2 3.5
    23. 3 a 3 3.5
    24. 1 b 1 7.0
    25. 4 b 4 7.0

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

    1. In [61]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
    2. Out[61]:
    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 [62]: lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio',
    2. ....: 'Nevada', 'Nevada'],
    3. ....: 'key2': [2000, 2001, 2002, 2001, 2002],
    4. ....: 'data': np.arange(5.)})
    5. In [63]: righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
    6. ....: index=[['Nevada', 'Nevada', 'Ohio', 'Ohio',
    7. ....: 'Ohio', 'Ohio'],
    8. ....: [2001, 2000, 2000, 2000, 2001, 2002]],
    9. ....: columns=['event1', 'event2'])
    10. In [64]: lefth
    11. Out[64]:
    12. data key1 key2
    13. 0 0.0 Ohio 2000
    14. 1 1.0 Ohio 2001
    15. 2 2.0 Ohio 2002
    16. 3 3.0 Nevada 2001
    17. 4 4.0 Nevada 2002
    18. In [65]: righth
    19. Out[65]:
    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

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

    1. In [66]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
    2. Out[66]:
    3. data key1 key2 event1 event2
    4. 0 0.0 Ohio 2000 4 5
    5. 0 0.0 Ohio 2000 6 7
    6. 1 1.0 Ohio 2001 8 9
    7. 2 2.0 Ohio 2002 10 11
    8. 3 3.0 Nevada 2001 0 1
    9. In [67]: pd.merge(lefth, righth, left_on=['key1', 'key2'],
    10. ....: right_index=True, how='outer')
    11. Out[67]:
    12. data key1 key2 event1 event2
    13. 0 0.0 Ohio 2000 4.0 5.0
    14. 0 0.0 Ohio 2000 6.0 7.0
    15. 1 1.0 Ohio 2001 8.0 9.0
    16. 2 2.0 Ohio 2002 10.0 11.0
    17. 3 3.0 Nevada 2001 0.0 1.0
    18. 4 4.0 Nevada 2002 NaN NaN
    19. 4 NaN Nevada 2000 2.0 3.0

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

    1. In [68]: left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
    2. ....: index=['a', 'c', 'e'],
    3. ....: columns=['Ohio', 'Nevada'])
    4. In [69]: right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
    5. ....: index=['b', 'c', 'd', 'e'],
    6. ....: columns=['Missouri', 'Alabama'])
    7. In [70]: left2
    8. Out[70]:
    9. Ohio Nevada
    10. a 1.0 2.0
    11. c 3.0 4.0
    12. e 5.0 6.0
    13. In [71]: right2
    14. Out[71]:
    15. Missouri Alabama
    16. b 7.0 8.0
    17. c 9.0 10.0
    18. d 11.0 12.0
    19. e 13.0 14.0
    20. In [72]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
    21. Out[72]:
    22. Ohio Nevada Missouri Alabama
    23. a 1.0 2.0 NaN NaN
    24. b NaN NaN 7.0 8.0
    25. c 3.0 4.0 9.0 10.0
    26. d NaN NaN 11.0 12.0
    27. e 5.0 6.0 13.0 14.0

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

    1. In [73]: left2.join(right2, how='outer')
    2. Out[73]:
    3. Ohio Nevada Missouri Alabama
    4. a 1.0 2.0 NaN NaN
    5. b NaN NaN 7.0 8.0
    6. c 3.0 4.0 9.0 10.0
    7. d NaN NaN 11.0 12.0
    8. e 5.0 6.0 13.0 14.0

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

    1. In [74]: left1.join(right1, on='key')
    2. Out[74]:
    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 [75]: another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
    2. ....: index=['a', 'c', 'e', 'f'],
    3. ....: columns=['New York',
    4. 'Oregon'])
    5. In [76]: another
    6. Out[76]:
    7. New York Oregon
    8. a 7.0 8.0
    9. c 9.0 10.0
    10. e 11.0 12.0
    11. f 16.0 17.0
    12. In [77]: left2.join([right2, another])
    13. Out[77]:
    14. Ohio Nevada Missouri Alabama New York Oregon
    15. a 1.0 2.0 NaN NaN 7.0 8.0
    16. c 3.0 4.0 9.0 10.0 9.0 10.0
    17. e 5.0 6.0 13.0 14.0 11.0 12.0
    18. In [78]: left2.join([right2, another], how='outer')
    19. Out[78]:
    20. Ohio Nevada Missouri Alabama New York Oregon
    21. a 1.0 2.0 NaN NaN 7.0 8.0
    22. b NaN NaN 7.0 8.0 NaN NaN
    23. c 3.0 4.0 9.0 10.0 9.0 10.0
    24. d NaN NaN 11.0 12.0 NaN NaN
    25. e 5.0 6.0 13.0 14.0 11.0 12.0
    26. f NaN NaN NaN NaN 16.0 17.0

    轴向连接

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

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

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

    • 如果对象在其它轴上的索引不同,我们应该合并这些轴的不同元素还是只使用交集?
    • 连接的数据集是否需要在结果对象中可识别?
    • 连接轴中保存的数据是否需要保留?许多情况下,DataFrame默认的整数标签最好在连接时删掉。

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

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

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

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

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

    1. In [86]: pd.concat([s1, s2, s3], axis=1)
    2. Out[86]:
    3. 0 1 2
    4. a 0.0 NaN NaN
    5. b 1.0 NaN NaN
    6. c NaN 2.0 NaN
    7. d NaN 3.0 NaN
    8. e NaN 4.0 NaN
    9. f NaN NaN 5.0
    10. g NaN NaN 6.0

    这种情况下,另外的轴上没有重叠,从索引的有序并集(外连接)上就可以看出来。传入join=’inner’即可得到它们的交集:

    1. In [87]: s4 = pd.concat([s1, s3])
    2. In [88]: s4
    3. Out[88]:
    4. a 0
    5. b 1
    6. f 5
    7. g 6
    8. dtype: int64
    9. In [89]: pd.concat([s1, s4], axis=1)
    10. Out[89]:
    11. 0 1
    12. a 0.0 0
    13. b 1.0 1
    14. f NaN 5
    15. g NaN 6
    16. In [90]: pd.concat([s1, s4], axis=1, join='inner')
    17. Out[90]:
    18. 0 1
    19. a 0 0
    20. b 1 1

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

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

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

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

    1. In [92]: result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
    2. In [93]: result
    3. Out[93]:
    4. one a 0
    5. b 1
    6. two a 0
    7. b 1
    8. three f 5
    9. g 6
    10. dtype: int64
    11. In [94]: result.unstack()
    12. Out[94]:
    13. a b f g
    14. one 0.0 1.0 NaN NaN
    15. two 0.0 1.0 NaN NaN
    16. three NaN NaN 5.0 6.0

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

    1. In [95]: pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
    2. Out[95]:
    3. one two three
    4. a 0.0 NaN NaN
    5. b 1.0 NaN NaN
    6. c NaN 2.0 NaN
    7. d NaN 3.0 NaN
    8. e NaN 4.0 NaN
    9. f NaN NaN 5.0
    10. g NaN NaN 6.0

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

    1. In [96]: df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
    2. ....: columns=['one', 'two'])
    3. In [97]: df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
    4. ....: columns=['three', 'four'])
    5. In [98]: df1
    6. Out[98]:
    7. one two
    8. a 0 1
    9. b 2 3
    10. c 4 5
    11. In [99]: df2
    12. Out[99]:
    13. three four
    14. a 5 6
    15. c 7 8
    16. In [100]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
    17. Out[100]:
    18. level1 level2
    19. one two three four
    20. a 0 1 5.0 6.0
    21. b 2 3 NaN NaN
    22. c 4 5 7.0 8.0

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

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

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

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

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

    1. In [103]: df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
    2. In [104]: df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
    3. In [105]: df1
    4. Out[105]:
    5. a b c d
    6. 0 1.246435 1.007189 -1.296221 0.274992
    7. 1 0.228913 1.352917 0.886429 -2.001637
    8. 2 -0.371843 1.669025 -0.438570 -0.539741
    9. In [106]: df2
    10. Out[106]:
    11. b d a
    12. 0 0.476985 3.248944 -1.021228
    13. 1 -0.577087 0.124121 0.302614

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

    1. In [107]: pd.concat([df1, df2], ignore_index=True)
    2. Out[107]:
    3. a b c d
    4. 0 1.246435 1.007189 -1.296221 0.274992
    5. 1 0.228913 1.352917 0.886429 -2.001637
    6. 2 -0.371843 1.669025 -0.438570 -0.539741
    7. 3 -1.021228 0.476985 NaN 3.248944
    8. 4 0.302614 -0.577087 NaN 0.124121

    表8-3 concat函数的参数

    合并重叠数据

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

    1. In [108]: a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
    2. .....: index=['f', 'e', 'd', 'c', 'b', 'a'])
    3. In [109]: b = pd.Series(np.arange(len(a), dtype=np.float64),
    4. .....: index=['f', 'e', 'd', 'c', 'b', 'a'])
    5. In [110]: b[-1] = np.nan
    6. In [111]: a
    7. Out[111]:
    8. f NaN
    9. e 2.5
    10. d NaN
    11. c 3.5
    12. b 4.5
    13. a NaN
    14. dtype: float64
    15. In [112]: b
    16. Out[112]:
    17. f 0.0
    18. e 1.0
    19. d 2.0
    20. c 3.0
    21. b 4.0
    22. a NaN
    23. dtype: float64
    24. In [113]: np.where(pd.isnull(a), b, a)
    25. Out[113]: array([ 0. , 2.5, 2. , 3.5, 4.5, nan])

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

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

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

    1. In [115]: df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
    2. .....: 'b': [np.nan, 2., np.nan, 6.],
    3. .....: 'c': range(2, 18, 4)})
    4. In [116]: df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],
    5. .....: 'b': [np.nan, 3., 4., 6., 8.]})
    6. In [117]: df1
    7. Out[117]:
    8. a b c
    9. 0 1.0 NaN 2
    10. 1 NaN 2.0 6
    11. 2 5.0 NaN 10
    12. 3 NaN 6.0 14
    13. In [118]: df2
    14. Out[118]:
    15. a b
    16. 0 5.0 NaN
    17. 1 4.0 3.0
    18. 2 NaN 4.0
    19. 3 3.0 6.0
    20. 4 7.0 8.0
    21. In [119]: df1.combine_first(df2)
    22. Out[119]:
    23. a b c
    24. 0 1.0 NaN 2.0
    25. 1 4.0 2.0 6.0
    26. 2 5.0 4.0 10.0
    27. 3 3.0 6.0 14.0
    28. 4 7.0 8.0 NaN