如何在Pandas中合并两个DataFrames？

在数据分析中，经常需要将多个数据表进行合并，以便进行进一步的数据分析。Pandas是Python语言中应用广泛的数据分析库，它提供了丰富的数据操作和处理功能，包括数据读写、数据过滤、数值运算、数据分组、数据绘制等。本文将介绍如何在Pandas中合并两个DataFrames，涉及到的知识点包括Pandas中的merge、join、concat等函数的使用方法。

更多Pandas相关文章，请阅读：Pandas 教程

准备工作

在开始合并DataFrames之前，需要先准备两个DataFrame对象。假设我们有以下两个简单的DataFrame：

import pandas as pd

# 第一个DataFrame
df1 = pd.DataFrame({
    "key": ["A", "B", "C", "D"],
    "value1": [1, 2, 3, 4],
})

# 第二个DataFrame
df2 = pd.DataFrame({
    "key": ["B", "D", "E", "F"],
    "value2": [5, 6, 7, 8],
})

其中，df1有一个名为“key”的列和一个名为“value1”的列，df2同样有一个名为“key”的列和一个名为“value2”的列。

merge函数的用法

merge函数是Pandas中用于合并两个DataFrame的基本函数。它将两个DataFrame中的行通过某些相同的列（即“连接键”）进行合并，并输出一个新的DataFrame。假设我们需要根据“key”列将df1和df2进行合并，代码如下：

# 合并df1和df2
merged_df = pd.merge(df1, df2, on="key")

# 输出合并后的DataFrame
print(merged_df)

运行代码后，输出结果如下：

  key  value1  value2
0   B       2       5
1   D       4       6

结果包含一个名为“key”的列和两个值列“value1”和“value2”，只有在df1中存在的“C”和在df2中存在的“E”和“F”被排除了。此外，merge函数会默认使用“inner”方式进行连接操作。

如果需要使用不同的连接方式，可以通过指定“how”参数来进行设置。Pandas中支持的连接方式包括“inner”、“outer”、“left”和“right”四种。例如，如下代码将使用“outer”方式进行连接：

# 使用outer方式合并df1和df2
merged_df = pd.merge(df1, df2, on="key", how="outer")

# 输出合并后的DataFrame
print(merged_df)

输出结果如下：

  key  value1  value2
0   A     1.0     NaN
1   B     2.0     5.0
2   C     3.0     NaN
3   D     4.0     6.0
4   E     NaN     7.0
5   F     NaN     8.0

可以看到，使用“outer”方式使得合并后的结果包含了df1和df2中的所有记录，缺失的值用NaN进行标记。

除了指定连接方式，merge函数还支持通过“left_on”和“right_on”参数来指定在两个DataFrame中进行合并的列名不同的情况。例如，如下代码将使用不同的列名进行合并：

# 使用不同的列名进行合并
df1 = pd.DataFrame({
    "key1": ["A", "B", "C", "D"],
    "value1": [1, 2, 3, 4],
})

df2 = pd.DataFrame({
    "key2": ["B", "D", "E", "F"],
    "value2": [5, 6, 7, 8],
})

merged_df = pd.merge(df1, df2, left_on="key1", right_on="key2")

#输出结果如下：

```python
  key1  value1 key2  value2
0    B       2    B       5
1    D       4    D       6

可以看到，merge函数通过指定“left_on”和“right_on”参数将具有不同列名的两个DataFrame进行了合并。

merge函数的完整用法如下：

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
         left_index=False, right_index=False, sort=True, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

其中，参数含义如下：

• left：左侧DataFrame对象。
• right：右侧DataFrame对象。
• how：连接方式（inner、outer、left、right），默认为“inner”。
• on：连接键，可以是列名、列组合或索引。（其中left_on和right_on两个参数需要同时指定）
• left_on：左侧DataFrame中用作连接键的列名或列名列表。
• right_on：右侧DataFrame中用作连接键的列名或列名列表。
• left_index：如果为True，则使用左侧DataFrame中的索引作为连接键，必须与right_index=False一起使用。
• right_index：如果为True，则使用右侧DataFrame中的索引作为连接键，必须与left_index=False一起使用。
• sort：默认为True，如果为False，则不排序连接结果。
• suffixes：如果存在重复的列名，则分别给左侧和右侧DataFrame的重复列添加后缀，默认为(‘_x’, ‘_y’)。
• indicator：表示是否在输出结果中添加一列指示数据来源。
• validate：可选的字符串，用于检查合并的数据是否符合某些特定的条件。

join函数的用法

除了merge函数外，Pandas还提供了另一个用于合并DataFrame的函数——join函数。join函数与merge函数相似，但对于在连接键上的重复值的处理方式不同。与merge函数中的“how”参数不同，join函数中的“how”参数指定连接方式的方式是使用join函数的方法之一。

例如，对于具有相同行标签的两个DataFrame，join函数将自动使用“left join”使这些行一起出现在输出DataFrame中的一行中。例如，我们可以创建两个DataFrame，每个DataFrame都由一些具有相同行标签的行组成：

# 创建两个具有相同行标签的DataFrame
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]}, index=['row1', 'row2'])
df2 = pd.DataFrame({'C': [5, 6], 'D': [7, 8]}, index=['row1', 'row2'])

print(df1)
print(df2)

输出结果如下：

      A  B
row1  1  3
row2  2  4

      C  D
row1  5  7
row2  6  8

然后，我们可以使用join方法将它们合并在一起：

# 使用join方法将两个DataFrame合并
merged_df = df1.join(df2)

# 输出合并后的DataFrame
print(merged_df)

输出结果如下：

      A  B  C  D
row1  1  3  5  7
row2  2  4  6  8

可以看到，使用join方法使得df1和df2中的所有记录都被包含在合并后的DataFrame中。

需要注意的是，join函数默认使用“left join”方式进行连接。如果需要使用其他连接方式，则需要通过指定“how”参数进行设置。例如：

# 使用“outer join”方式进行连接
merged_df = df1.join(df2, how="outer")

join函数的完整用法如下：

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

其中，参数含义如下：

• other：要加入到DataFrame中的另一个DataFrame或Series对象。
• on：合并时使用的列或索引。
• how：连接方式（inner、outer、left、right），默认为“left”。
• lsuffix：左侧重复列的后缀。
• rsuffix：右侧重复列的后缀。
• sort：默认为False，如果为True，则按照连接键对结果进行排序。

concat函数的用法

除了merge和join函数，Pandas还提供了concat函数用于在一个轴上将多个DataFrame对象连接在一起。使用concat函数可以实现横向（水平）和纵向（垂直）的拼接操作。

例如，我们可以使用以下代码创建三个DataFrame对象：

df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [3, 4], 'B': [6, 7]})
df3 = pd.DataFrame({'A': [5, 6], 'B': [8, 9]})

接着，我们可以使用concat函数将这三个DataFrame对象纵向拼接在一起：

# 纵向拼接三个DataFrame对象
result = pd.concat([df1, df2, df3])

# 输出拼接后的DataFrame对象
print(result)

输出结果如下：

   A  B
0  1  3
1  2  4
0  3  6
1  4  7
0  5  8
1  6  9

可以看到，concat函数将三个DataFrame对象沿着纵向（垂直）轴进行拼接，生成一个新的DataFrame对象。

除了纵向拼接，concat函数还可以用于横向（水平）拼接。例如，我们可以使用以下代码创建两个DataFrame对象：

# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'C': [5, 6], 'D': [7, 8]})

接着，我们可以使用concat函数将这两个DataFrame对象横向拼接在一起：

# 横向拼接两个DataFrame对象
result = pd.concat([df1, df2], axis=1)

# 输出拼接后的DataFrame对象
print(result)

输出结果如下：

   A  B  C  D
0  1  3  5  7
1  2  4  6  8

可以看到，concat函数将两个DataFrame对象沿着横向（水平）轴进行拼接，生成一个新的DataFrame对象。

需要注意的是，在使用concat函数时，需要保证所要连接的DataFrame对象具有相同的列名或行标签。否则，将会出现NaN值。

concat函数的完整用法如下：

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)

其中，常用参数含义如下：

• objs：一个列表或字典，其中包含要合并的DataFrame对象。
• axis：拼接DataFrame沿着的轴，0表示纵向轴，1表示横向轴。
• join：用于指定DataFrame对象拼接后的连接方式，取值可以为“inner”或“outer”。
• ignore_index：如果为True，则忽略原始DataFrame对象中的行标签，并在合并后的结果中重新编制行标签。
• keys：由多个索引分层的标签，用于区分每个DataFrame的来源。
• verify_integrity：如果为真，则验证拼接操作是否会导致结果中的重复行。