python 两个dataframe去除相同元素 python两个dataframe合并

2.合并数据集

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

1. pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。
2. pandas.concat可以沿着一条轴将多个对象堆叠到一起。
3. 实例方法combine_first可以将重复数据拼接在一起，用一个对象中的值填充另 一个对象中的缺失值。

①数据库风格的DataFrame合并

1.多对一的合并

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

In [23]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],'data': range(7)})

In [24]: df1
Out[24]:
   data key
0     0   b
1     1   b
2     2   a
3     3   c
4     4   a
5     5   a
6     6   b

In [25]: df2 = pd.DataFrame({'key':['a', 'b', 'd'], 'data2': range(3)})

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

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

In [27]: pd.merge(df1, df2)
Out[27]:
   data 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将会用重叠的列名当做键，这里既是key。我们可以确定一下：

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

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

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

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

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

记住，当用merge进行连接时，两个DataFrame的位置和lefton和right_on参数对于的键名必须一一对应，不然会报错。

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

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

对于how选项的总结：

注：how选项的默认值是inner。

In [54]: pd.merge(df1, df2, how='left')
Out[54]:
   data key  data2
0     0   b    1.0
1     1   b    1.0
2     2   a    0.0
3     3   c    NaN
4     4   a    0.0
5     5   a    0.0
6     6   b    1.0

In [55]: pd.merge(df1, df2, how='right')
Out[55]:
   data key  data2
0   0.0   b      1
1   1.0   b      1
2   6.0   b      1
3   2.0   a      0
4   4.0   a      0
5   5.0   a      0
6   NaN   d      2

2.多对多的合并，看下面的例子：

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

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

In [58]: right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
    ...:                      'key2': ['one', 'one', 'one', 'two'],
    ...:                      'rval': [14, 5, 6, 7]})
    ...:

In [59]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
    ...:                      'key2': ['one', 'two', 'one'],
    ...:                      'lval': [1, 2, 3]})
    ...:

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

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

In [62]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
Out[62]:
  key1 key2  lval  rval
0  foo  one   1.0  14.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 [63]: pd.merge(left, right, on='key1')
Out[63]:
  key1 key2_x  lval key2_y  rval
0  foo    one     1    one    14
1  foo    one     1    one     5
2  foo    two     2    one    14
3  foo    two     2    one     5
4  bar    one     3    one     6
5  bar    one     3    two     7

In [64]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
Out[64]:
  key1 key2_left  lval key2_right  rval
0  foo       one     1        one    14
1  foo       one     1        one     5
2  foo       two     2        one    14
3  foo       two     2        one     5
4  bar       one     3        one     6
5  bar       one     3        two     7

merge函数的参数：

②索引上的合并

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

left_index=True是指将左侧的行索引作为其连接键，right_index=True是指将右侧的行索引作为连接键。

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

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

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

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

In [7]: pd.merge(left1, right1, left_on='key', right_index=True)
Out[7]:
  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 [8]: pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
Out[8]:
  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 [10]: lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
    ...:                       'key2': [2000, 2001, 2002, 2001, 2002],
    ...:                       'data': np.arange(5.)})
    ...:

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

In [12]: lefth
Out[12]:
   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 [13]: righth
Out[13]:
             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 [14]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
Out[14]:
   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 [15]: pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True, how='outer')
Out[15]:
   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 [16]: left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
    ...:                      index=['a', 'c', 'e'],
    ...:                      columns=['Ohio', 'Nevada'])
    ...:

In [17]: right2 = pd.DataFrame([[7., 8.], [9.,10.], [11., 12.], [13.,14.]],
    ...:                         index=['b', 'c', 'd', 'e'],
    ...:                         columns=['Missouri', 'Alabama'])
    ...:

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

In [19]: right2
Out[19]:
   Missouri  Alabama
b       7.0      8.0
c       9.0     10.0
d      11.0     12.0
e      13.0     14.0

In [20]: pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
Out[20]:
   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 [21]: left2.join(right2, how='outer')
Out[21]:
   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 [23]: left1
Out[23]:
  key  value
0   a      0
1   b      1
2   a      2
3   a      3
4   b      4
5   c      5

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

In [25]: left1.join(right1, on='key')
Out[25]:
  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

③轴向连接

另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠

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

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

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

In [29]: np.concatenate([arr, arr], axis=1)
Out[29]:
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]])

concatenation函数默认axis=0（列连接），axis=1行连接。

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

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

pandas的concat函数提供了一种能够解决这些问题的可靠方式。下面将给出一些例子来讲解其使用方式。

假设有三个没有重叠索引的Series：

In [30]: s1 = pd.Series([0, 1], index=['a', 'b'])

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

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

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

In [33]: pd.concat([s1, s2, s3])
Out[33]:
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 [34]: pd.concat([s1, s2, s3], axis=1)
Out[34]:
     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'即可得到它们的交集，所以这里的连接默认是外连接（join='outer'）：

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

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

In [37]: pd.concat([s1, s4],axis=1)
Out[37]:
     0  1
a  0.0  0
b  1.0  1
f  NaN  5
g  NaN  6

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

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

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

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

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

假设你想要在连接轴上创建一个层次化索引，使参与连接的片段在结果中区分开。使用keys参数即可达到这个目的：（这是沿着axis=0合并的，默认）

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

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

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

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

In [45]: result
Out[45]:
   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 [46]: df1 = pd.DataFrame(np.arange(6).reshape(3,2),index=['a', 'b', 'c'],columns=['one',
    ...: 'two'])

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

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

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

In [52]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
Out[52]:
  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 [53]: pd.concat({'level1': df1, 'level2': df2},axis=1)
Out[53]:
  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

此外还有两个用于管理层次化索引创建方式的参数。举个例子，我们可以用names参数命名创建的轴级别：

In [54]: pd.concat([df1, df2], axis=1, keys=['level1', 'level2'], names=['upper', 'lower'])
Out[54]:
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 [55]: df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])

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

In [57]: df1
Out[57]:
          a         b         c         d
0  0.462592 -0.483619 -0.309090  0.346428
1  0.095334  1.995289 -1.506938 -1.463913
2 -0.536354  1.757570  0.245877 -0.619046

In [58]: df2
Out[58]:
          b         d         a
0  0.397341  1.188116 -1.728195
1 -0.936105  0.116097  2.243444

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

In [59]: pd.concat([df1, df2], ignore_index=True)
Out[59]:
          a         b         c         d
0  0.462592 -0.483619 -0.309090  0.346428
1  0.095334  1.995289 -1.506938 -1.463913
2 -0.536354  1.757570  0.245877 -0.619046
3 -1.728195  0.397341       NaN  1.188116
4  2.243444 -0.936105       NaN  0.116097

关于concat函数的参数：

④合并重叠数据

还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算 来处理。比如说，你可能有索引全部或部分重叠的两个数据集。

举个有启发性的例子，我们使用NumPy的where函数，它表示一种等价于面向数组的if-else：

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

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

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

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

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

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

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

In [71]: a.combine_first(b)
Out[71]:
f    0.0
e    2.5
d    2.0
c    3.5
b    4.5
a    NaN
dtype: float64              ##用b的值填补a中的缺失值

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

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

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

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

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

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