Question

Pandas非常擅长处理数据分析中的各种用例。探索文档以确定执行特定任务的最佳方式可能有点令人生畏。

我目前正在尝试了解pd.DataFrame.merge()和pd.concat()之间的本质区别。到目前为止，这是我能说清楚的：

.merge()只能使用列（加上行索引），它在语义上适用于数据库样式的操作。 .concat()可以与任一轴一起使用，仅使用索引，并提供添加分层索引的选项。

顺便提一下，这允许以下冗余：两者都可以使用行索引组合两个数据帧。

至于pd.DataFrame.join()，它似乎只是提供了.merge()用例子集的简写。

有人可以评论我此时的理解是否完整和准确吗？

谢谢。

Answer 1

非常高级别的差异是#!/bin/bash #SBATCH -A XXXXXXX #SBATCH -J testRun #SBTACH -o output/testOutput #SBATCH -n 1 #SBATCH -p projectName #SBATCH -t 00:01:00 ibrun ./test用于根据公共列的值组合两个（或更多）数据帧（也可以使用索引，使用merge()和/或{ {1}}），left_index=True用于将一个（或多个）数据框一个接一个地追加（或横向，取决于right_index=True选项是否设置为0或1）。

concat()用于根据索引合并2个数据帧;我们可以使用axis。

，而不是将join()与merge()选项一起使用

例如：

left_index=True

Answer 2

pd.concat以Iterable为参数。因此，它不能直接将DataFrame作为其参数。 Dimension的{{1}}也应该在连接时沿轴匹配。

DataFrame可以将pd.merge作为其参数，并用于将两个DataFrame与相同的列或索引合并，而DataFrame无法完成因为它会在DataFrame中显示重复的列。

而join可用于连接具有不同索引的两个pd.concat。

Answer 3

高层次：

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

更具体地说，.concat()：

是顶级熊猫功能
结合两个或更多熊猫DataFrame 垂直或水平
在水平组合时仅在索引上对齐
DataFrame中的任何一个包含重复索引时出错。
默认为外部联接，带有内部联接选项

还有.merge()：

同时作为顶级熊猫函数和DataFrame方法存在（自熊猫1.0起）
水平准确地将两个DataFrame组合在一起
将调用DataFrame的列或索引与其他列对齐 DataFrame的列或索引
通过以下方式处理联接列或索引上的重复值：执行笛卡尔积
默认为内部联接，带有左，外和右选项

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

实际上是：

在组合齐次.concat()时首先考虑DataFrame，而结合互补的.merge()时，请先考虑DataFrame。
如果需要垂直合并，请使用.concat()。如果需要合并通过列在水平方向上与.merge()一起使用，默认情况下clear合并在列上。

参考：Pandas 1.x Cookbook

Answer 4

merge＆concat之间的主要区别在于，merge使您可以对concat的使用范围更广且结构化程度更低的表执行结构化的“联接”。

合并

引用documentation，pd.DataFrame.merge将 right 作为必需参数，您可以将其视为根据一些预定义的结构化联接来联接left表和right表操作。请注意参数 right 的定义。

必需参数

正确：DataFrame或命名为Series

可选参数

操作方式：{“左”，“右”，“外部”，“内部”}默认为“内部”
上：标签或列表
left_on ：标签或列表，或类似数组的
right_on ：标签或列表，或类似数组的
left_index ：bool，默认为False
right_index ：bool，默认为False
sort ：bool，默认为False
后缀：（str，str）的元组，默认（'_x'，'_y'）
copy ：bool，默认为True
指标：bool或str，默认为False
validate ：str，可选

重要提示：：pd.DataFrame.merge要求权限是pd.DataFrame或命名为pd.Series的对象。

输出

返回：DataFrame

此外，如果我们在下面检查熊猫的合并操作的文档字符串，则如下：

在两个DataFrame或Series之间执行数据库（SQL）合并操作使用列作为键或它们的行索引的对象

Concat

请参阅pd.concat中的documentation，首先请注意，该参数未命名为 table，data_frame，series，matrix 等中的任何一个，而是命名为 objs 。也就是说，您可以传递许多“数据容器”，它们定义为：

Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]

必需参数

objs ：Series或DataFrame对象的序列或映射

可选参数

轴：{0 /“索引”，1 /“列”}，默认值为0
加入：{“内部”，“外部”}，默认为“外部”
ignore_index ：bool，默认为False
键：序列，默认为无
级别：序列列表，默认为无
名称：列表，默认为无
verify_integrity ：bool，默认为False
sort ：bool，默认为False
copy ：bool，默认为True

输出

返回：对象，objs类型

示例

代码

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

，您无法通过合并执行类似的操作，因为它仅允许单个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

结论

您可能已经注意到，“合并”和“合并”之间的输入和输出可能不同。

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

总而言之，合并对更改/（输入）的容忍度较低，而“ concat”对更改/（输入）的容忍度较低/较不敏感。 您可以使用“ concat”实现“合并”，但并非总是如此。

“合并”操作使用数据框列（或pd.Series对象的名称）或行索引，并且由于仅使用这些实体，因此它执行数据框或系列的水平合并，并且不将垂直操作应用于结果。

如果您想了解更多，可以稍微深入一下源代码；

concat的源代码
merge的源代码

Answer 5

我目前正在尝试了解pd.DataFrame.merge()和pd.concat()之间的本质区别。

好问题。主要区别：

`pd.concat`在两个轴上都起作用。

另一个区别是pd.concat具有内部 ^{^默认}和外部仅连接，而pd.DataFrame.merge()具有左，右，外部，内部 ^{^默认}加入。

第三个明显的不同是：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

Answer 6

只有concat函数具有轴参数。合并用于根据共享列中的值并排合并数据帧，因此不需要轴参数。

Answer 7

默认情况下：
    join是列式左连接
    pd.merge是按列的内部联接
    pd.concat是按行的外部联接

pd.concat：
带有Iterable参数。因此，它不能直接采用DataFrames（使用[df，df2]）
DataFrame的尺寸应沿轴

匹配

加入并合并：
可以接受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]，轴= 1）

pandas中merge（）和concat（）之间的差异

7 个答案:

`pd.concat`在两个轴上都起作用。

pandas中merge（）和concat（）之间的差异

7 个答案:

pd.concat在两个轴上都起作用。

`pd.concat`在两个轴上都起作用。