python pandas如何合并两个dataframe_pandas merge与concat合并数据框方法

下次还敢

发布时间：2025-09-12 15:29:01

753人浏览过

来源于php中文网

原创

pandas中merge用于基于键的关系型连接，如SQL的JOIN，适合通过共同列或索引关联数据；concat则用于沿轴堆叠DataFrame，类似UNION ALL，适用于简单拼接。选择merge当需根据逻辑关系（如客户ID）整合数据，选择concat当需直接堆叠行或列。其他方法如join、combine_first等在特定场景下补充使用。

python pandas如何合并两个dataframe_pandas merge与concat合并数据框方法

在Pandas中，合并两个DataFrame主要通过

merge

和

concat

两个核心函数实现。简单来说，

merge

更侧重于基于一个或多个共同的键（列或索引）进行“关系型”连接，类似于SQL中的JOIN操作，它关注的是数据之间的逻辑关联。而

concat

则更倾向于“堆叠”或“拼接”，它按照指定的轴（行或列）将多个DataFrame简单地堆叠在一起，更像是SQL中的UNION ALL。选择哪个取决于你的数据如何关联以及你希望达到的合并效果。

解决方案

pandas.merge

用于基于共同的列或索引来合并DataFrame。它在功能上与数据库的JOIN操作非常相似，可以处理一对一、一对多、多对多的关系。

import pandas as pd

# 示例数据
df1 = pd.DataFrame({
    'id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'city': ['NY', 'LA', 'SF', 'NY']
})

df2 = pd.DataFrame({
    'id': [1, 2, 5, 3],
    'salary': [70000, 80000, 90000, 75000],
    'department': ['HR', 'IT', 'Finance', 'HR']
})

# 内连接 (inner merge): 仅保留两个DataFrame中'id'列都有的行
merged_df_inner = pd.merge(df1, df2, on='id', how='inner')
# print("内连接结果:\n", merged_df_inner)

# 左连接 (left merge): 保留左DataFrame的所有行，匹配右DataFrame的行；右DataFrame不匹配的用NaN填充
merged_df_left = pd.merge(df1, df2, on='id', how='left')
# print("\n左连接结果:\n", merged_df_left)

# 右连接 (right merge): 保留右DataFrame的所有行，匹配左DataFrame的行；左DataFrame不匹配的用NaN填充
merged_df_right = pd.merge(df1, df2, on='id', how='right')
# print("\n右连接结果:\n", merged_df_right)

# 外连接 (outer merge): 保留两个DataFrame的所有行，不匹配的用NaN填充
merged_df_outer = pd.merge(df1, df2, on='id', how='outer')
# print("\n外连接结果:\n", merged_df_outer)

# 基于多个键合并
df3 = pd.DataFrame({
    'first_name': ['Alice', 'Bob'],
    'last_name': ['Smith', 'Johnson'],
    'age': [30, 24]
})

df4 = pd.DataFrame({
    'first_name': ['Alice', 'Bob'],
    'last_name': ['Smith', 'Johnson'],
    'occupation': ['Engineer', 'Designer']
})

merged_multi_key = pd.merge(df3, df4, on=['first_name', 'last_name'])
# print("\n多键合并结果:\n", merged_multi_key)

# 基于索引合并
df5 = pd.DataFrame({'value1': [10, 20]}, index=['A', 'B'])
df6 = pd.DataFrame({'value2': [30, 40]}, index=['B', 'C'])
merged_on_index = pd.merge(df5, df6, left_index=True, right_index=True, how='outer')
# print("\n基于索引合并结果:\n", merged_on_index)

pandas.concat

用于将多个DataFrame或Series沿一个轴（行或列）进行拼接。它更像是一个“堆叠”操作，而不是基于键的匹配。

立即学习“Python免费学习笔记（深入）”；

import pandas as pd

# 示例数据
df_a = pd.DataFrame({
    'col1': [1, 2],
    'col2': ['A', 'B']
})

df_b = pd.DataFrame({
    'col1': [3, 4],
    'col2': ['C', 'D']
})

df_c = pd.DataFrame({
    'col3': [5, 6],
    'col4': ['E', 'F']
})

# 沿行方向拼接 (axis=0, 默认行为)
concatenated_rows = pd.concat([df_a, df_b])
# print("沿行方向拼接结果:\n", concatenated_rows)

# 沿行方向拼接并重置索引
concatenated_rows_reset_index = pd.concat([df_a, df_b], ignore_index=True)
# print("\n沿行方向拼接并重置索引结果:\n", concatenated_rows_reset_index)

# 沿列方向拼接 (axis=1)
concatenated_cols = pd.concat([df_a, df_c], axis=1)
# print("\n沿列方向拼接结果:\n", concatenated_cols)

# 沿列方向拼接，即使索引不完全匹配
df_d = pd.DataFrame({'col_x': [10, 20]}, index=[0, 2])
df_e = pd.DataFrame({'col_y': [30, 40]}, index=[0, 1])
concatenated_cols_mismatch_index = pd.concat([df_d, df_e], axis=1)
# print("\n沿列方向拼接，索引不匹配:\n", concatenated_cols_mismatch_index)

# 使用keys参数为每个DataFrame添加一个层级索引
concatenated_with_keys = pd.concat([df_a, df_b], keys=['group_a', 'group_b'])
# print("\n使用keys参数拼接结果:\n", concatenated_with_keys)

在什么场景下，我应该选择使用

pandas.merge

而非

concat

？

这是一个非常关键的问题，因为选择错误可能会导致数据分析结果出现偏差。从我的经验来看，当你需要基于数据之间的“逻辑关系”来组合它们时，

merge

是首选。想象一下你有两张表，一张是客户的基本信息（ID、姓名、地址），另一张是客户的订单记录（订单ID、客户ID、商品、金额）。这两张表通过“客户ID”这个共同的字段关联起来。你想知道每个客户都买了什么，或者每个订单是哪个客户下的，这时候就应该使用

merge

。

merge

的核心在于它的“连接键”(

on

参数指定列，或

left_index

right_index

指定索引)。它会寻找两个DataFrame中连接键值相同的行，然后将它们组合成一行。这种基于键的匹配是关系型数据库操作的基石，它允许你根据预定义的规则（如

how

参数：

inner

left

right

outer

）来决定哪些匹配或不匹配的行应该被保留。

例如，如果你想：

关联不同来源的相同实体信息：比如一个部门员工的基础信息表和另一个记录他们绩效考核的表，通过员工ID进行关联。
整合分层数据：像上面提到的客户信息和订单信息，或者产品信息和销售数据。
进行查找或筛选：你可能想找出所有在特定城市居住的员工的薪资，这需要将员工信息和薪资信息通过某种键连接起来。

总的来说，当你的数据结构是“宽”的，并且你希望通过一个或多个共同的标识符来扩展或聚合现有数据时，

merge

就是你的利器。它能帮你处理一对一、一对多，甚至多对多的复杂关系，让数据保持其原有的逻辑完整性。而

concat

在这种情况下就显得力不从心，它只会简单地堆叠，不会去理解数据行之间的内在联系。

pandas.concat

在处理多张表数据时有哪些常见陷阱和最佳实践？

concat

虽然直观，但在实际使用中也常会遇到一些小麻烦。我见过不少人因为不注意这些细节，导致数据混乱或者分析结果出错。

PathFinder

AI驱动的销售漏斗分析工具

下载

常见陷阱：

索引混乱： 默认情况下，
```
concat
```
会保留原始DataFrame的索引。如果你沿行方向（
```
axis=0
```
）拼接多个DataFrame，并且它们的索引有重叠或者不是唯一的，那么结果DataFrame的索引也会有重复值。这在后续的数据查询和操作中可能造成混淆。比如，你可能有两个DataFrame都包含索引
```
0, 1, 2
```
，拼接后会有两组
```
0, 1, 2
```
，这通常不是你想要的。
列名不匹配： 当你沿行方向拼接时，如果参与拼接的DataFrame列名不完全一致，
```
concat
```
会默认进行外连接（
```
outer
```
），即保留所有DataFrame中出现过的列，不匹配的行用
```
NaN
```
填充。这可能导致结果DataFrame出现大量空值，或者意外地增加了你并不关心的列。反之，如果你希望只保留所有DataFrame都有的列，你需要明确指定
```
join='inner'
```
。
数据类型不一致： 如果不同DataFrame中相同列的数据类型不一致（例如，一个DataFrame的某列是整数，另一个是字符串），
```
concat
```
会尝试寻找一个兼容的通用数据类型。这通常会导致数字列被转换为对象类型（字符串），从而影响后续的数值计算。
顺序依赖：
```
concat
```
是按照你传入的DataFrame列表的顺序进行拼接的。如果顺序很重要，你需要确保列表中的DataFrame排列正确。

最佳实践：

重置索引 (
ignore_index=True
)：如果你只是想简单地将数据堆叠起来，并且不关心原始索引的含义，那么在
```
concat
```
时设置
```
ignore_index=True
```
是一个非常好的习惯。它会生成一个全新的、从0开始的连续整数索引，避免了索引重复的问题。
```
# 避免索引重复的最佳实践
df_combined = pd.concat([df_a, df_b], ignore_index=True)
```
明确指定连接方式 (
join='inner'
)：当沿行方向拼接时，如果只关心所有DataFrame都存在的列，可以设置
```
join='inner'
```
来避免引入不必要的
```
NaN
```
列。
```
# 只保留共同列的最佳实践
df_combined_inner_cols = pd.concat([df_a, df_with_different_cols], join='inner')
```
使用
keys
参数添加层级索引：如果你想保留每个原始DataFrame的来源信息，
```
keys
```
参数非常有用。它会在结果DataFrame中创建一个新的外层索引，清晰地标示出每行数据来自哪个原始DataFrame。这对于追溯数据来源或者进行分组分析非常有帮助。
```
# 保留来源信息的最佳实践
df_with_source_info = pd.concat([df_a, df_b], keys=['source_A', 'source_B'])
# df_with_source_info.loc['source_A'] 可以访问来自df_a的数据
```
预处理数据类型： 在
```
concat
```
之前，检查并统一所有DataFrame中相同列的数据类型。可以使用
```
.astype()
```
方法进行转换，确保数据类型的一致性，避免不必要的类型提升。
处理列名不一致： 如果列名不一致是由于拼写错误或命名规范不同造成的，最好在
```
concat
```
之前进行列名重命名，确保数据的整洁性。

除了

merge

和

concat

，还有哪些Pandas方法可以实现数据框的连接或组合？

当然，Pandas提供了不止

merge

和

concat

来处理数据框的连接与组合，虽然这两个是最常用且功能最强大的。其他一些方法在特定场景下也很有用，或者提供了更简洁的语法糖。

```
.join()
```
方法：
```
DataFrame.join()
```
是
```
merge
```
的一个语法糖，专门用于基于索引或指定列进行连接。它的主要特点是默认使用左连接（
```
how='left'
```
），并且通常更方便用于基于索引的连接。如果两个DataFrame都有相同的索引，或者一个DataFrame的索引与另一个DataFrame的某个列匹配，
```
join
```
就显得非常简洁。
```
df_left = pd.DataFrame({'value_a': [1, 2]}, index=['A', 'B'])
df_right = pd.DataFrame({'value_b': [3, 4]}, index=['B', 'C'])
joined_df = df_left.join(df_right, how='outer') # 默认是left，这里演示outer
# print(joined_df)
```
它在内部其实还是调用了
```
merge
```
，但对于索引连接的场景，我个人觉得
```
join
```
的写法更直观。
```
.append()
```
方法（已弃用，推荐使用
concat
）：在旧版本的Pandas中，
```
DataFrame.append()
```
方法曾被广泛用于将一个DataFrame的行添加到另一个DataFrame的末尾。它的功能与
```
pd.concat([df1, df2], axis=0)
```
非常相似，但一次只能操作两个DataFrame。
```
# df_a.append(df_b, ignore_index=True) # 旧用法，现在会发出警告
# 推荐使用：
# pd.concat([df_a, df_b], ignore_index=True)
```
从Pandas 1.4版本开始，
```
append()
```
方法已经被弃用，官方推荐使用
```
pd.concat()
```
来替代它，因为
```
concat
```
功能更强大，性能也更好，并且能同时处理多个DataFrame。
```
.combine()
```
和
.combine_first()
方法：这两个方法用于按元素级别组合两个DataFrame。它们不是进行关系型连接，而是当两个DataFrame在相同位置有数据时，如何选择值。
- .combine()
  ：接受一个函数作为参数，该函数决定如何组合两个DataFrame中相同位置的非NaN值。
```
df_x = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df_y = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
combined_max = df_x.combine(df_y, lambda s1, s2: s1 if s1 > s2 else s2)
# print(combined_max) # 会在每个位置选择较大的值
```
- .combine_first()
  ：用另一个DataFrame中的非NaN值填充当前DataFrame中的NaN值。这在处理缺失数据时非常有用，比如你想用一个备用数据源来填充主数据源中的空缺。
```
df_main = pd.DataFrame({'A': [1, np.nan], 'B': [3, 4]})
df_backup = pd.DataFrame({'A': [5, 6], 'B': [7, np.nan]})
filled_df = df_main.combine_first(df_backup)
# print(filled_df) # df_main中的NaN会被df_backup的对应值填充
```
  这两个方法更侧重于数据的“填充”或“合并策略”，而不是基于键的结构化连接。它们在数据清洗和预处理阶段能发挥独特的作用。