Pandas中合并DataFrame主要用pd.merge()和pd.concat()，前者基于键进行类似SQL的连接操作，后者按行或列堆叠数据。merge()适用于有共同键的逻辑关联数据，支持inner、left、right、outer等连接方式；concat()用于结构相似的数据拼接，默认按行堆叠，可设置join='inner'保留公共部分。常见陷阱包括键类型不一致、列名不同、索引重复及NaN处理问题。此外，.join()方法适合基于索引的合并，map()可用于高效添加单列信息。选择合适方法需根据数据结构与整合目标决定。
在Python中，合并两个Pandas DataFrame的核心方法主要围绕
pd.merge()和
pd.concat()这两个函数展开。它们分别对应着关系型数据库中的连接操作（基于共同的键）和简单的堆叠或拼接操作（基于行或列）。理解它们的适用场景和参数至关重要，能帮助我们高效地整合零散的数据。
解决方案
合并Pandas DataFrame，我们通常会根据数据的结构和我们想要达成的目标来选择
merge()或
concat()。
pd.merge()函数是用于将两个DataFrame基于一个或多个键进行合并，类似于SQL中的JOIN操作。它能够处理一对一、一对多、多对一以及多对多的关系。
举个例子，假设我们有两个DataFrame，一个包含用户信息，另一个包含用户的订单信息：
立即学习“Python免费学习笔记（深入）”；
import pandas as pd
# 用户信息
df_users = pd.DataFrame({
'user_id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David'],
'city': ['New York', 'London', 'Paris', 'Tokyo']
})
# 订单信息
df_orders = pd.DataFrame({
'order_id': [101, 102, 103, 104, 105],
'user_id': [1, 2, 1, 3, 5], # 注意user_id 5 不在df_users中
'product': ['Laptop', 'Mouse', 'Keyboard', 'Monitor', 'Webcam'],
'price': [1200, 25, 75, 300, 50]
})
print("df_users:")
print(df_users)
print("\ndf_orders:")
print(df_orders)使用pd.merge()
进行合并：
最常见的合并类型是内连接（inner join），它只保留两个DataFrame中键都存在的行。
# 内连接：只保留两个DataFrame中user_id都存在的行
merged_inner = pd.merge(df_users, df_orders, on='user_id', how='inner')
print("\nInner Join (merged_inner):")
print(merged_inner)如果我们需要保留所有用户信息，即使他们没有订单，那就需要左连接（left join）：
# 左连接：保留左边DataFrame的所有行，匹配右边DataFrame的行
merged_left = pd.merge(df_users, df_orders, on='user_id', how='left')
print("\nLeft Join (merged_left):")
print(merged_left)反过来，如果想保留所有订单信息，即使对应的用户不在用户信息表中，就是右连接（right join）：
# 右连接：保留右边DataFrame的所有行，匹配左边DataFrame的行
merged_right = pd.merge(df_users, df_orders, on='user_id', how='right')
print("\nRight Join (merged_right):")
print(merged_right)当然，还有外连接（outer join），它会保留两个DataFrame中的所有行，不匹配的地方用NaN填充：
# 外连接：保留两个DataFrame的所有行
merged_outer = pd.merge(df_users, df_orders, on='user_id', how='outer')
print("\nOuter Join (merged_outer):")
print(merged_outer)使用pd.concat()
进行合并：
pd.concat()则更像是堆叠或拼接，它可以按行（axis=0，默认）或按列（axis=1）将多个DataFrame连接起来。这在处理结构相似但数据来源不同的DataFrame时特别有用，比如多个月份的销售数据。
假设我们有两部分用户数据：
df_users_part1 = pd.DataFrame({
'user_id': [1, 2],
'name': ['Alice', 'Bob']
})
df_users_part2 = pd.DataFrame({
'user_id': [3, 4],
'name': ['Charlie', 'David']
})
print("\ndf_users_part1:")
print(df_users_part1)
print("\ndf_users_part2:")
print(df_users_part2)
# 按行合并 (堆叠)
concatenated_rows = pd.concat([df_users_part1, df_users_part2])
print("\nConcatenated by rows:")
print(concatenated_rows)如果两个DataFrame的行索引或列索引不完全匹配，
concat默认会进行外连接式的合并，不匹配的地方用NaN填充。如果你想只保留共同的列，可以设置
join='inner'。
# 假设df_users_part1有额外列
df_users_part1_ext = pd.DataFrame({
'user_id': [1, 2],
'name': ['Alice', 'Bob'],
'email': ['alice@example.com', 'bob@example.com']
})
df_users_part2_simple = pd.DataFrame({
'user_id': [3, 4],
'name': ['Charlie', 'David']
})
# 默认join='outer'
concatenated_mixed_cols = pd.concat([df_users_part1_ext, df_users_part2_simple])
print("\nConcatenated with mixed columns (default outer join):")
print(concatenated_mixed_cols)
# 只保留共同的列
concatenated_inner_cols = pd.concat([df_users_part1_ext, df_users_part2_simple], join='inner')
print("\nConcatenated with inner join on columns:")
print(concatenated_inner_cols)Pandas中merge()
和concat()
函数的主要区别是什么？
在我看来，
merge()和
concat()虽然都能实现数据整合，但它们解决的问题和背后的逻辑是截然不同的。我通常把
merge()看作是“智能”的、基于关系的连接，而
concat()则是“直接”的、基于位置或维度的拼接。
merge()的核心在于键（key）。它要求你指定一个或多个共同的列作为连接的“桥梁”，然后根据这些键的匹配情况，将两个DataFrame的行进行横向组合。这就像你在数据库里做JOIN操作一样，非常适合处理那种“这个表里有ID，那个表里也有ID，我想把它们对应起来”的场景。比如，你想把客户的基本信息和他们的购买记录关联起来，
merge()就是不二之选。它有
inner、
left、
right、
outer等多种连接方式，让你能精确控制哪些数据应该被保留下来，哪些应该被丢弃或用空值填充。我个人在使用时，最常用的是
left和
inner，因为它们能很好地控制结果集的范围。
而
concat()则更像是“堆积木”。它不关心数据内容上的逻辑关联，只关心你希望把DataFrame们按哪个轴（行或列）堆叠起来。如果你有一堆结构完全相同（或至少大部分相同）的DataFrame，比如每个月导出的销售报表，你只是想把它们首尾相连地堆成一个大的DataFrame，那
concat()就是最直接、最有效率的方法。它默认是按行堆叠（
axis=0），也可以按列堆叠（
axis=1），但按列堆叠时，通常要求DataFrame的行索引是匹配的，否则也会出现很多NaN。它没有
merge()那种复杂的匹配逻辑，所以处理起来也更直接，性能上往往也更快，尤其是在处理大量结构相似的数据块时。
简而言之，当你的数据之间存在明确的“一对一”、“一对多”或“多对多”的逻辑关系，需要通过共同的标识符来关联时，用
merge()。当你只是想把多个DataFrame简单地“粘”在一起，形成一个更大、更长的DataFrame时，用
concat()。
处理DataFrame合并时常见的陷阱有哪些？
在实际操作中，合并DataFrame确实有一些坑，我个人就踩过不少。理解这些常见问题能帮我们省下很多调试时间。
一个非常常见的陷阱是键列的数据类型不一致。比如说，一个DataFrame的
user_id列是整数类型，另一个DataFrame的
user_id列却是字符串类型。即便它们看起来都是
'1'、
'2'，
merge()函数也会认为它们是不同的值，导致合并失败或者结果集为空。这种问题往往比较隐蔽，因为打印出来看，值都是一样的。我通常会在合并前，先用
df['column'].dtype检查一下数据类型，必要时用
df['column'].astype(str)或
astype(int)进行转换。
另一个坑是键列名不一致。比如一个表是
user_id，另一个是
UserID。
merge()默认会尝试寻找两个DataFrame中同名的列作为键。如果列名不同，你需要明确指定
left_on和
right_on参数，否则Pandas会报错或者生成一个笛卡尔积（如果两个DataFrame都没有共同列名，并且你没有指定
on参数）。我习惯在数据清洗阶段就统一列名，这能避免很多后期合并的麻烦。
索引问题也是
concat()经常遇到的一个“小麻烦”。当你按行堆叠多个DataFrame时，如果它们有相同的索引值，
concat()会保留这些重复的索引。这在某些情况下可能不是你想要的，比如你希望得到一个从0开始的连续索引。这时，就需要使用
ignore_index=True参数，它会在合并后重新生成一个默认的整数索引。如果没有这个操作，后续基于索引的操作可能会出现意想不到的结果。
此外，处理缺失值（NaN）也是一个需要注意的地方。特别是使用
left、
right或
outer连接时，不匹配的行会填充NaN。这些NaN在后续的数据分析或计算中可能会引起错误。我通常会在合并后，根据业务需求决定如何处理这些NaN，比如用0填充、用均值填充，或者直接删除包含NaN的行。这没有一个通用的最佳实践，完全取决于数据和分析目的。
最后，性能问题在大数据集合并时也不容忽视。如果你的DataFrame非常大，不恰当的合并操作可能会消耗大量内存和计算时间。例如，在没有必要的情况下使用
outer连接，可能会生成一个非常大的结果集。有时，预先筛选掉不需要的行或列，或者在合并前对键列进行索引优化（虽然Pandas内部已经做了很多优化），都能有效提升性能。
除了merge()
和concat()
，还有哪些DataFrame合并策略？
确实，
merge()和
concat()是Pandas合并DataFrame的两大主力，但在某些特定场景下，我们还有一些其他的策略或者说是变体，可以更高效或更优雅地完成任务。
一个非常实用的替代方案是DataFrame对象的.join()
方法。这个方法其实是
pd.merge()的一个语法糖，专门用于基于索引或一个DataFrame的索引与另一个DataFrame的列进行合并。我个人觉得它在处理那些一个DataFrame的索引本身就是另一个DataFrame的“键”时，用起来特别顺手。
例如，如果我们想把订单信息
df_orders和用户信息
df_users通过
user_id连接，但
df_users的
user_id是其索引：
# 将df_users的user_id设置为索引
df_users_indexed = df_users.set_index('user_id')
print("\ndf_users_indexed:")
print(df_users_indexed)
# 使用join方法，df_orders的user_id列与df_users_indexed的索引进行匹配
# left_on指定左边DataFrame的列，right_index=True表示右边DataFrame用索引
joined_df = df_orders.join(df_users_indexed, on='user_id', how='left')
print("\nJoined using .join() method:")
print(joined_df).join()方法的默认行为是左连接（
how='left'），并且默认是基于索引进行连接。当一个DataFrame的索引是另一个DataFrame的某个列时，
join()会比
merge()写起来更简洁。
另一个值得一提的策略是pd.Series.map()
或pd.DataFrame.apply()
结合字典或函数进行“查找”式的数据补充。这严格来说不是合并，但它能实现类似“根据一个DataFrame的某一列的值，去另一个DataFrame或字典中查找对应值并填充到新列”的效果。当你的查找表较小，或者只需要根据一个键添加少量列时，这种方法会非常高效。
例如，我们想根据
df_orders中的
user_id，从
df_users中获取用户的
name和
city，但不是合并整个DataFrame，而是只添加这两列：
# 创建一个user_id到name的映射字典
user_name_map = df_users.set_index('user_id')['name'].to_dict()
user_city_map = df_users.set_index('user_id')['city'].to_dict()
# 使用map方法将name和city添加到df_orders
df_orders_with_details = df_orders.copy()
df_orders_with_details['user_name'] = df_orders_with_details['user_id'].map(user_name_map)
df_orders_with_details['user_city'] = df_orders_with_details['user_id'].map(user_city_map)
print("\nOrders with user details added via .map():")
print(df_orders_with_details)这种方式的优点是，它不会像
merge()那样生成一个全新的、可能包含重复列或更多行的DataFrame，而是直接在原DataFrame上增加列，对于性能和内存占用都有优势，尤其是在只需要少量信息时。不过，它的缺点是只能一次添加一列，并且对于复杂的连接条件就不适用了。
最后，对于一些非常规的、需要高度自定义的合并逻辑，我们有时会退而求其次，手动迭代或使用apply()
配合自定义函数来处理。但这通常是效率最低、最不推荐的方式，只有在Pandas内置的
merge()、
concat()或
join()无法满足需求时，才考虑这种“暴力”解决方案。我个人几乎没遇到过需要这样做的场景，因为Pandas的合并功能已经非常强大了。
总的来说，理解这些不同的策略，并根据具体的数据结构和业务需求灵活选择，是成为一个高效Pandas用户的重要一步。
