一个非常高的级别差异是，merge()用于根据公共列的值（也可以使用索引，使用left_index=True和/或right_index=True）来合并组合两个（或多个）嵌套框，而concat()用于将一个（或多个）嵌套框一个接一个地附加在另一个下面（或横向，取决于axis选项设置为0还是1）。
join()用于根据索引合并2个字符串;我们可以使用join()来代替merge()和left_index=True选项。
举例来说：

df1 = pd.DataFrame({'Key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})

df1:
   Key  data1
0   b   0
1   b   1
2   a   2
3   c   3
4   a   4
5   a   5
6   b   6

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

df2:
    Key data2
0   a   0
1   b   1
2   d   2

#Merge
# The 2 dataframes are merged on the basis of values in column "Key" as it is 
# a common column in 2 dataframes

pd.merge(df1, df2)

   Key data1 data2
0   b    0    1
1   b    1    1
2   b    6    1
3   a    2    0
4   a    4    0
5   a    5    0

#Concat
# df2 dataframe is appended at the bottom of df1 

pd.concat([df1, df2])

   Key data1 data2
0   b   0     NaN
1   b   1     NaN
2   a   2     NaN
3   c   3     NaN
4   a   4     NaN
5   a   5     NaN
6   b   6     NaN
0   a   Nan   0
1   b   Nan   1
2   d   Nan   2

字符串

在高级别：

• .concat()只是将多个DataFrame垂直堆叠在一起，或在索引上对齐后水平缝合
• .merge()首先对齐两个DataFrame选定的公共列或索引，然后从每个DataFrame的对齐行中拾取剩余的列。

更具体地说，.concat()：

• 是一个顶级pandas函数
• 将两个或多个pandas DataFrame垂直或水平组合
• 水平组合时仅在索引上对齐
• 当任何DataFrame包含重复索引时出错。
• 带内部联接选项的外部联接

.merge()：

• 同时作为顶级pandas函数和DataFrame方法（从pandas 1.0开始）
• 水平组合两个DataFrame
• 将调用DataFrame的列或索引与其他DataFrame的列或索引对齐
• 通过执行Carbonate乘积处理联接列或索引上的重复值
• 带左、外和右选项的内联接

请注意，在执行pd.merge(left, right)时，如果left有两行包含来自连接列或索引的相同值，则每行将与right的相应行合并组合，从而产生carryover乘积。另一方面，如果.concat()用于合并组合列，则需要确保DataFrame中不存在重复的索引。

实际上：

• 当组合齐次DataFrame时，首先考虑.concat()，而当组合互补DataFrame时，首先考虑.merge()。
• 如果需要垂直合并，使用.concat()。如果需要通过列合并，使用.merge()，默认情况下合并公共列。

参考：Pandas 1.x Cookbook

pd.concat将Iterable作为其参数。因此，它不能直接将DataFrame s作为其参数。此外，DataFrame的Dimension s在连接时应沿沿着轴匹配。
pd.merge可以将DataFrame s作为其参数，并用于合并将两个具有相同列或索引的DataFrame s合并，这在pd.concat中无法完成，因为它将在DataFrame中显示重复的列。
而join可以用来连接两个索引不同的DataFrame。

我目前正在尝试理解pd.DataFrame.merge()和pd.concat()之间的本质区别。
好问题。主要区别：

pd.concat在两个轴上都工作。

另一个区别是，pd.concat只有 innerdefault和 outer joins，而pd.DataFrame.merge()有 * left*，right，outer，inner defaultjoins。
第三个值得注意的区别是：pd.DataFrame.merge()在合并同名列时可以选择设置列后缀，而pd.concat则不可以。
使用pd.concat默认情况下，您可以堆叠多个嵌套帧（axis=0）的行，当您设置axis=1时，您可以模拟pd.DataFrame.merge()功能。
pd.concat的一些有用的例子：

df2=pd.concat([df]*2, ignore_index=True) #double the rows of a dataframe

df2=pd.concat([df, df.iloc[[0]]]) # add first row to the end

df3=pd.concat([df1,df2], join='inner', ignore_index=True) # concat two df's

字符串

merge和concat之间的主要区别是merge允许你在concat的使用更广泛和更少结构化的情况下执行更结构化的表“联接”。

合并

参考documentation，pd.DataFrame.merge将 right 作为必需参数，您可以将其视为根据某些预定义的结构化连接操作连接左表和右表。请注意参数 right 的定义。

• 必填参数 *
• right：DataFrame或命名Series
• 可选参数 *
• how：返回'left'，'right'，'outer'，'inner'}默认值为'inner'
• on：标签或列表
• left_on：标签或列表，或类似数组
• right_on：标签或列表，或类似数组
• left_index：bool，默认为False
• right_index：bool，默认为False
• sort：bool，default False
• • 后缀 *：元组（str，str），默认（'_x'，'_y'）
• copy：bool，默认True
• indicator：bool或str，默认为False
• validate：str，可选
  重要提示：pd.DataFrame.merge需要权限才能成为pd.DataFrame或命名pd.Series对象。
  输出
• • 返回值 *：DataFrame

此外，如果我们检查pandas上的合并操作的文档字符串，则如下所示：
在两个DataFrame或Series对象之间执行数据库（SQL）合并操作，将列用作键或使用其行索引

Concat

参考pd.concat的documentation，首先注意参数的命名不是 table、data_frame、series、matrix 等中的任何一个，而是 objs。也就是说，可以传递很多“数据容器”，定义为：
Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]个

必填参数

• objs：Series或DataFrame对象的序列或Map
• 可选参数 *
• axis：{0/'index'，1/'columns'}，默认值为0
• join：连接'inner'，'outer'}，默认值为'outer'
• ignore_index：bool，默认为False
• keys：序列，默认无
• levels：序列列表，默认为None
• names：list，default无
• verify_integrity：bool，默认为False
• sort：bool，default False
• copy：bool，默认True
• 输出 *
• Returns：对象，对象类型
  示例
• 验证码 *

import pandas as pd

v1 = pd.Series([1, 5, 9, 13])
v2 = pd.Series([10, 100, 1000, 10000])
v3 = pd.Series([0, 1, 2, 3])

df_left = pd.DataFrame({
    "v1": v1,
    "v2": v2,
    "v3": v3
    })
df_right = pd.DataFrame({
    "v4": [5, 5, 5, 5],
    "v5": [3, 2, 1, 0]
    })

df_concat = pd.concat([v1, v2, v3])

# Performing operations on default

merge_result = df_left.merge(df_right, left_index=True, right_index=True)
concat_result = pd.concat([df_left, df_right], sort=False)
print(merge_result)
print('='*20)
print(concat_result)

字符串

• 代码输出 *

v1     v2  v3  v4  v5
0   1     10   0   5   3
1   5    100   1   5   2
2   9   1000   2   5   1
3  13  10000   3   5   0
====================
     v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0

型
但是，您可以通过更改 axis 参数来实现concat的第一个输出（合并

concat_result = pd.concat([df_left, df_right], sort=False, axis=1)

型
观察以下行为，

concat_result = pd.concat([df_left, df_right, df_left, df_right], sort=False)

型
产出;

v1       v2   v3   v4   v5
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0
0   1.0     10.0  0.0  NaN  NaN
1   5.0    100.0  1.0  NaN  NaN
2   9.0   1000.0  2.0  NaN  NaN
3  13.0  10000.0  3.0  NaN  NaN
0   NaN      NaN  NaN  5.0  3.0
1   NaN      NaN  NaN  5.0  2.0
2   NaN      NaN  NaN  5.0  1.0
3   NaN      NaN  NaN  5.0  0.0

型
，您不能对merge执行类似的操作，因为它只允许单个DataFrame或命名Series。

merge_result = df_left.merge([df_right, df_left, df_right], left_index=True, right_index=True)

型
产出;

TypeError: Can only merge Series or DataFrame objects, a <class 'list'> was passed

型

结论

你可能已经注意到了，“merge”和“concat”之间的输入和输出可能不同。

**正如我在开始时提到的，第一个（主要）区别是“merge”执行一个更结构化的连接，带有一组受限的对象和参数，而“concat”执行一个不太严格/更广泛的连接，带有一组更广泛的对象和参数。

总而言之，merge对更改/（输入）的容忍度较低，而“concat”对更改/（输入）的敏感度较低。* 您可以使用“concat”实现“merge”，但反过来并不总是正确的。*
“合并”操作使用 Dataframe 列（或pd.Series对象的名称）或行索引，由于它只使用这些实体，因此它执行 Dataframe 或系列的水平合并，而不应用垂直操作。
如果你想了解更多，你可以深入研究一下源代码;

• concat的源代码
• 合并的源代码

concat方法与SQL中的UNION ALL操作符完全相同。（如SQL），但也可沿列轴沿着（如果你concat两个每个3列的嵌套，你会得到一个6列的新嵌套）。join和merge方法与SQL中的JOIN相同，尽管后者更强大并且是最常用的。

只有concat函数有axis参数。Merge用于根据共享列中的值并排合并合并多个框架，因此不需要axis参数。

默认情况下：
join是按列左联接
merge是一个按列的内部连接
concat是一个按行的外部连接
pd.concat:
接受Iterable参数。因此，它不能直接接受DataFrames（使用[df，df2]）
DataFrame的尺寸应沿沿着轴匹配
Join和pd.merge：
可以接受DataFrame参数
Click to see picture for understanding why code below does the same thing

df1.join(df2)
pd.merge(df1, df2, left_index=True, right_index=True)
pd.concat([df1, df2], axis=1)

字符串