熊猫中 merge()和 concat()的区别

小开

一个非常高的级别差异是，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

小开

pd.concat的参数是 Iterable。因此，它不能直接以 DataFrame作为参数。DataFrame的 Dimension也应该沿着轴匹配，同时连接。

pd.merge可以使用 DataFrame作为参数，并用于将两个具有相同列或索引的 DataFrame组合在一起，而 pd.concat不能这样做，因为它将在 DataFrame 中显示重复的列。

而 join 可以用来连接两个具有不同索引的 DataFrame。

小开

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

问得好，主要区别是:

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

另一个区别是 pd.concat只有内部^{< sup > < b > default} 和外围连接，而 pd.DataFrame.merge()有左边、右边、外围、内部^{< sup > < b > default} 连接。

第三个值得注意的区别是: 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

小开

默认情况下:
Join 是列方向的左连接
Merge 是一个列方式的内部连接
Concat 是一个行方向的外部连接

联系:
因此，它不能直接接受 DataFrames (使用[ df，df2])
数据框架的尺寸应该沿着轴匹配

加入合并:
可以接受 DataFrame 参数

点击查看图片了解为什么下面的代码做同样的事情

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

小开

Merge & concat 之间的主要区别在于 merge 允许您执行结构化程度更高的表“ join”，其中 concat 的使用范围更广，结构化程度更低。

合并

通过引用文件，pd.DataFrame.merge将对作为必需的参数，您可以将其视为根据某种预定义的结构化连接操作连接左表和右表。请注意参数对的定义。

所需参数

右 : DataFrame 或命名系列

可选参数

如何 : {‘ left’，‘ right’，‘ foreign’，‘ inner’}默认的‘ inner’
在 : 标签或列表
Left _ on : 标签或列表，或类似数组
Right _ on : label or list，or array-like
Left _ index : bool，default False
Right _ index : bool，default False
Sort : bool，default False
后缀 : tuple of (str，str) ，default (‘ _ x’，‘ _ y’)
Copy : bool，default True
指示符 : bool 或 str，默认值为 False
验证 : str，可选

重要提示: pd.DataFrame.merge需要权限为 pd.DataFrame或命名为 pd.Series的对象。

输出

返回 : DataFrame

此外，如果我们检查关于熊猫合并操作的文档字符串如下:

在两个 DataFrame 或 Series 之间执行数据库(SQL)合并操作使用列作为键或其行索引的

联系

参考 pd.concat中的文件，首先要注意的是，这个参数没有命名为 表，数据框架，系列，矩阵中的任何一个，而是命名为物体。也就是说，您可以传递许多“数据容器”，它们被定义为:

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

所需参数

Objecs : Series 或 DataFrame 对象的序列或映射

可选参数

坐标轴 : {0/’索引’，1/’列’} ，默认值为0
Join : {‘ inner’，‘ outer’} ，默认的‘ outer’
无视 _ index : bool，default False
密钥 : 序列，默认值为“无”
级别 : 序列列表，默认值为无
Name : list，default Nothing
Valid_ Integrity : bool，default False 验证 _ 完整性 : bool，默认值为 False
Sort : bool，default False
Copy : bool，default True

输出

返回 : 对象，对象类型

例子

密码

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

但是，您可以通过更改轴参数来实现使用 concat 的第一个输出(merge)

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”对更改/(输入)的敏感度较低

“合并”操作使用数据框架列(或 pd.Series对象的名称)或行索引，因为它只使用这些实体，所以它执行数据框架或系列的水平合并，因此不应用垂直操作。

如果你想看到更多，你可以深入一点的源代码;

连接的源代码
合并的源代码

小开

在高层:

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

更具体地说，.concat():

是大熊猫的顶级功能
结合两个或两个以上的熊猫 DataFrame 垂直的或水平
水平组合时对 只在索引上有
当任何 DataFrame包含重复索引时出现错误。
默认为外部连接，并带有内部连接选项

还有 .merge():

既作为一个顶级熊猫函数存在，也作为一个 DataFrame方法存在(从熊猫1.0开始)
水平方向正好合并了两个 DataFrame
将调用 DataFrame的列或索引与其他 DataFrame的列或索引
处理 连接列或索引上的重复值 表演笛卡儿积
默认设置为内部连接，其中包含左、外和右选项

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

实际上:

当组合同质 DataFrame时，首先考虑 .concat()，而在组合互补 DataFrame时首先考虑 .merge()。
如果需要垂直合并，使用 .concat()。如果需要合并水平地通过列，使用 .merge()，默认情况下它与共同的列合并。

参考资料: 熊猫1.x 食谱

小开

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

熊猫中 merge()和 concat()的区别

pd.concat 在两个轴上工作。

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