Python之数据合并——【concat（）函数、merge（）函数、join（）⽅法、
c。。。
⽂章⽬录
轴向堆叠数据——concat()函数
objs: Union[
Iterable[FrameOrSeriesUnion], Mapping[Optional[Hashable], FrameOrSeriesUnion]
],
axis=0,
join=“outer”,
ignore_index: bool = False,
keys=None,
levels=None,
names=None,
verify_integrity: bool = False,
sort: bool = False,
copy: bool = True,
)
上述函数中常⽤参数表⽰的含义如下：
join：表⽰连接的⽅式，inner表⽰内连接，outer表⽰外连接，默认使⽤外连接。
ignore_index：接受布尔值，默认为False。如果设置为True，则表⽰清除现有索引并重置索引值。
keys：接受序列，表⽰添加最外层索引。
levels：⽤于构建MultiIndex的特定级别（唯⼀值）
names：在设置了keys和levels参数后，⽤于创建分层级别的名称
verify_integerity：检查新的连接轴是否包含重复项。接收布尔值，当设置为True时，如果有重复的轴将会抛出错误，默认为False
根据轴⽅向的不同（axis参数），可以将堆叠分成横向堆叠和纵向堆叠，默认采⽤的是纵向堆叠⽅式。在堆叠数据时，默认采⽤的是外连接，(join参数设为outer)的⽅式。
横向堆叠与外连接
使⽤concat()函数合并时，若是将axis参数的值设为1，且join参数的值设为outer，则合并⽅式为横向堆叠与外连接。
测试对象：
left:
A  B
a  A0  B0
b  A1  B1
right:
C  D
c  C0  D0
d  C1  D1
代码：
left = pd.DataFrame({'A':['A0','A1'],
'B':['B0','B1']},
index=['a','b'])
right = pd.DataFrame({'C':['C0','C1'],
'D':['D0','D1']},
index=['c','d'])
at([left, right], join='outer', axis=1))
输出结果：
A    B    C    D
a  A0  B0  NaN  NaN
b  A1  B1  NaN  NaN
c  NaN  NaN  C0  D0
d  NaN  NaN  C1  D1
使⽤concat()函数合并之后产⽣的不存在的数据将⽤NaN进⾏填充。
纵向堆叠与内连接
使⽤concat()函数合并时，若是将axis参数的值设为0，且join参数的值设为inner，则合并⽅式为纵向堆叠与内连接。
测试对象：
df1:
A  B  C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
df2:
B  C  D
0  B3  C3  D3
1  B4  C4  D4
2  B5  C5  D5
代码：
df1 = pd.DataFrame({'A':['A0','A1','A2'],
'B':['B0','B1','B2'],
'C':['C0','C1','C2']})
df2 = pd.DataFrame({'B':['B3','B4','B5'],
'C':['C3','C4','C5'],
'D':['D3','D4','D5']})
at([df1, df2], join='inner', axis=0))
输出结果
B  C
0  B0  C0
1  B1  C1
2  B2  C2
0  B3  C3
1  B4  C4
2  B5  C5
主键合并数据——merge()函数
主键合并根据⼀个或多个键将不同的DaraFrame对象连接起来，⼤多数是将两个DataFrame对象中重叠的列作为合并的键。
merge(
left,
right,
how: str = “inner”,
on=None,
left_on=None,
right_on=None,
left_index: bool = False,
right_index: bool = False,
sort: bool = False,
suffixes=("_x", “_y”),
copy: bool = True,
indicator: bool = False,
validate=None,
)
上述函数中部分参数表⽰的含义如下：
1. left：参与合并的的左侧DataFrame对象
2. right：参与合并的的右侧DataFrame对象
3. how：表⽰连接⽅式，默认为inner，该参数⽀持以下的取值：
· left：使⽤左侧的DataFrame的键，类似于SQL的左外连接
· right：使⽤右侧的DataFrame的键，类似于SQL的右外连接· outer：使⽤两个DataFrame所有的键，类似于SQL的全连接· inner：使⽤两个DataFrame键的交集，类似于SQL的内连接
4. on：⽤于连接的列名。必须存在于左右两个DataFrame对象中
5. left_on：以左侧的DataFrame作为连接键
6. right_on：以右侧的DataFrame作为连接键
7. left_index：左侧的⾏索引⽤作连接键
8. right_index：右侧的⾏索引⽤作连接键
9. sort：是否排序，接受布尔值，默认为False
10. suffixes：⽤于追加都重叠列名的末尾，默认为(_x,_y)
内连接⽅式
默认采⽤how=inner的⽅式合并
测试对象：
df1:
A  B  C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
df3:
B  C  D
0  B0  C0  D3
1  B
2  C2  D4
2  B4  C4  D5
代码：
df1 = pd.DataFrame({'A':['A0','A1','A2'],
'B':['B0','B1','B2'],
'C':['C0','C1','C2']})
df3 = pd.DataFrame({'B':['B0','B2','B4'],
'C':['C0','C2','C4'],
'D':['D3','D4','D5']})
print("pd.merge:\n", pd.merge(df1, df3, on=['B','C']))
输出结果：
<:
A  B  C  D
0  A0  B0  C0  D3
1  A
2  B2  C2  D4
外连接⽅式
外连接⽅式（how=outer）：left与right列中相同的数据将会重叠，没有数据的位置使⽤NaN进⾏填充。
测试对象：
df1:
A  B  C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
df3:
B  C  D
0  B0  C0  D3
1  B
2  C2  D4
2  B4  C4  D5
代码：
print("pd.merge(how=outer):\n", pd.merge(df1, df3, on=['B','C'], how='outer'))
输出结果：
<(how=outer):
A  B  C    D
0  A0  B0  C0  D3
1  A1  B1  C1  NaN
2  A2  B2  C2  D4
3  NaN  B
4  C4  D5
左连接⽅式sql中union多表合并
左连接⽅式（how=left）：以左表作为基准进⾏连接，left表中的数据会全部显⽰，right表中只会显⽰与重叠数据⾏索引值相同的数据，合并后表中缺失的数据会使⽤NaN进⾏填充。
测试对象：
df1:
A  B  C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
df3:
B  C  D
0  B0  C0  D3
1  B
2  C2  D4
2  B4  C4  D5
代码：
print("pd.merge(how=left):\n", pd.merge(df1, df3, on=['B','C'], how='left'))
输出结果：
<(how=left):
A  B  C    D
0  A0  B0  C0  D3
1  A1  B1  C1  NaN
2  A2  B2  C2  D4
右连接⽅式
右连接⽅式（how=left）：以右表作为基准进⾏连接，right表中的数据会全部显⽰，left表中只会显⽰与重叠数据⾏索引值相同的数据，合并后表中缺失的数据会使⽤NaN进⾏填充。
测试对象：
df1:
A  B  C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
df3:
B  C  D
0  B0  C0  D3
1  B
2  C2  D4
2  B4  C4  D5
代码：
print("pd.merge(how=right):\n", pd.merge(df1, df3, on=['B','C'], how='right'))
测试结果：
<(how=right):
A  B  C  D
0  A0  B0  C0  D3
1  A
2  B2  C2  D4
2  NaN  B4  C4  D5
其他
即使两张表中的⾏索引与列索引均没有重叠的部分，也可以使⽤merge()函数来合并。只需要将参数left_index和right_index的值设置为True即可。
测试对象
left:
A  B
a  A0  B0
b  A1  B1
right:
C  D
c  C0  D0
d  C1  D1
代码：
print("pd.merge(left_index=right_index=True):\n",
<(left, right, how='outer', left_index=True, right_index=True))

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。