python合并json对象 python合并数据集

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

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

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

目录

1. 数据库风格的DataFrame合并

2. 索引上的合并

3. 轴向连接

4. 合并重叠数据

---

1. 数据库风格的DataFrame合并

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

以一个简单的例子开始:

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                    'data1': range(7)})
df2 = pd.DataFrame({'key': ['a', 'b', 'd'],
                    'data2': range(3)})
print(df1)
df2

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

pd.merge(df1, df2)

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

pd.merge(df1, df2, on='key')

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

df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                    'data1': range(7)})
df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],
                    'data2': range(3)})
pd.merge(df3, df4, left_on='lkey', right_on='rkey')

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

pd.merge(df1, df2, how='outer')

下表对这些选项进行了总结：

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

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
                    'data1': range(6)})
df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],
                    'data2': range(5)})
print(df1)
print(df2)
pd.merge(df1, df2, on='key', how='left')

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

pd.merge(df1, df2, how='inner')

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

left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
                     'key2': ['one', 'two', 'one'],
                     'lval': [1, 2, 3]})
right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
                      'key2': ['one', 'one', 'one', 'two'],
                      'rval': [4, 5, 6, 7]})
print(left)
print(right)
pd.merge(left, right, on=['key1', 'key2'], how='outer')

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

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

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

pd.merge(left, right, on='key1')

pd.merge(left, right, on='key1', suffixes=('_left', '_right'))

merge函数的参数:

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

2. 索引上的合并

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

left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
                      'value': range(6)})
right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
print(left1)
print(right1)
pd.merge(left1, right1, left_on='key', right_index=True)

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

pd.merge(left1, right1, left_on ='key', right_index=True, how='outer')

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

lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio',
                               'Nevada', 'Nevada'],
                      'key2': [2000, 2001, 2002, 2001, 2002],
                      'data': np.arange(5.)})
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'])
print(lefth)
print(righth)

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

pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)

pd.merge(lefth, righth, left_on=['key1', 'key2'],
         right_index=True, how='outer')

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

left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
                     index=['a', 'c', 'e'],
                     columns=['Ohio', 'Nevada'])
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
                      index=['b', 'c', 'd', 'e'],
                      columns=['Missouri', 'Alabama'])
print(left2)
print(right2)
pd.merge(left2, right2, how='outer', left_index=True, right_index=True)

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

left2.join(right2, how='outer')

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

print(left1)
print(right1)
left1.join(right1, on='key')

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

another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
                       index=['a', 'c', 'e', 'f'],
                       columns=['New York', 'Oregon'])
print(another) 
print(left2.join([right2, another]))
print(left2.join([right2, another], how='outer'))

 

3. 轴向连接

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

arr = np.arange(12).reshape((3, 4))
print(arr)
np.concatenate([arr, arr], axis=1)

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

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

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

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

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

pd.concat([s1, s2, s3])

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

pd.concat([s1, s2, s3], axis=1)

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

s4 = pd.concat([s1, s3])
print(s4)
print("-------------")
print(pd.concat([s1, s4], axis=1))
print("-------------")
print(pd.concat([s1, s4], axis=1, join='inner'))

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

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

pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])

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

result = pd.concat([s1, s1, s3], keys=['one', 'two', 'three'])
print(result)
result.unstack()

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

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

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

df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
                   columns=['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
                   columns=['three', 'four'])
print(df1)
print(df2)
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])

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

pd.concat({'level1': df1, 'level2': df2}, axis=1)

 

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

pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],
          names=['upper', 'lower'])

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

df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
print(df1)
df2

 

pd.concat([df1, df2], ignore_index=True)

 

4. 合并重叠数据

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

a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
              index=['f', 'e', 'd', 'c', 'b', 'a'])
b = pd.Series(np.arange(len(a), dtype=np.float64),
              index=['f', 'e', 'd', 'c', 'b', 'a'])
b[-1] = np.nan
print(a)
print("---------------")
print(b)
np.where(pd.isnull(a), b, a)

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

print(b[:-2])
print(a[2:])
b[:-2].combine_first(a[2:])

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

df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
                    'b': [np.nan, 2., np.nan, 6.],
                    'c': range(2, 18, 4)})
df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],
                    'b': [np.nan, 3., 4., 6., 8.]})
print(df1)
print("-----------------")
print(df2)
df1.combine_first(df2) #传递对象df2 调用对象df1