1. 数据连接merge
Python中merge()函数的表连接功能类似于Excel中实现拼接的vlookup()函数，也**类似于关系型数据库**的连接方式。merge()可以根据一个或多个键（列值）将不同的DataFrame连接起来。该函数的典型应用场景是，两张不同字段的表存在相同的键，根据键整合到一张表里面。
语法：
merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)
参数介绍：
| 参数key | 对应含义及值 |
|---|---|
| left和right | 两个不同的DataFrame |
| how | 连接方式，有inner、left、right、outer，默认为inner |
| on | 指的是用于连接的列索引名称，必须存在于左右两个DataFrame中，如果没有指定且其他参数也没有指定，则以两个DataFrame列名交集作为连接键 |
| left_on | 左侧DataFrame中用于连接键的列名，这个参数左右列名不同但代表的含义相同时非常的有用 |
| right_on | 右侧DataFrame中用于连接键的列名 |
| left_index | 使用左侧DataFrame中的行索引作为连接键 |
| right_index | 使用右侧DataFrame中的行索引作为连接键 |
| sort | 默认为True，将合并的数据进行排序，设置为False可以提高性能 |
| suffixes | 字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为('_x', '_y') |
| copy | 默认为True，总是将数据复制到数据结构中，设置为False可以提高性能 |
| indicator | 显示合并数据中数据的来源情况 |
几种连接方式:
用参数how来指明具体的连接方式，除了内连接（inner）还有左连接（left）、右连接（right）、外连接（outer）。效果如下图：
# 1. 单值key连接
# merge的默认的表连接方式是内连接
pd.merge(df1, df2,on='Key')
pd.merge(df1, df2,on='Key' , how='left')
pd.merge(df1, df2,on='Key' , how='right')
# 2.多键连接时将连接键组成列表传入
pd.merge(df1,df2,on=['key1','key2'], how='outer')
# 3.如果两个对象的列名不同，可以使用left_on，right_on分别指定
# key1 是左表的列名，key3是右表的列名
pd.merge(left,df3,left_on='key1',right_on='key3')
- 索引（多对应一）
df1 = pd.DataFrame(
{
"A": ["A0", "A1", "A2", "A3"],
"B": ["B0", "B1", "B2", "B3"],
"C": ["C0", "C1", "C2", "C3"],
"D": ["D0", "D1", "D2", "D3"],
},
index=[0, 1, 1, 3],
)
df2 = pd.DataFrame(
{
"E": ["D4", "D5", "D6", "D7"],
},
index=[0, 1, 2, 3],
)
# 一对应多
df_merge = pd.merge(df1, df2, left_index=True, right_index=True,how='right')
print(df_merge)
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
1 A2 B2 C2 D2 D5
2 NaN NaN NaN NaN D6
3 A3 B3 C3 D3 D7
# 多拼接一
df_merge = pd.merge(df1, df2, left_index=True, right_index=True,how='left')
print(df_merge)
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
1 A2 B2 C2 D2 D5
3 A3 B3 C3 D3 D7
# 以下因为索引问题会报错，这是一个区别
pd.concat([df1, df2],axis=1)
2. 数据合并-concat
沿着一条轴，将多个对象堆叠到一起
语法：
pd.concat(objs,axis=0,join=’outer’,join_axes=None,ignore_index=False,keys=None,levels=None,names=None,verify_integrity=False,sort=None,copy=True)
pd.concat()只是单纯的把两个表拼接在一起，参数axis是关键，它用于指定合并的轴是行还是列，axis默认是0（纵向拼接）。
参数介绍：
| 参数key | 对应含义及值 |
|---|---|
| objs | 需要连接的对象集合，一般是列表或字典 |
| axis | 连接轴向 |
| join | 参数为‘outer’或‘inner’ |
| ignore_index=True | 重建索引 |
df1 = pd.DataFrame(
{
"A": ["A0", "A1", "A2", "A3"],
"B": ["B0", "B1", "B2", "B3"],
"C": ["C0", "C1", "C2", "C3"],
"D": ["D0", "D1", "D2", "D3"],
},
index=[0, 1, 2, 3],
)
df2 = pd.DataFrame(
{
"E": ["D4", "D5", "D6", "D7"],
},
index=[0, 1, 2, 3],
)
concatenated_df = pd.concat([df1, df2],axis=1,join='outer')
print(concatenated_df)
'''
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
2 A2 B2 C2 D2 D6
3 A3 B3 C3 D3 D7
'''
concatenated_df = pd.concat([df1, df2], axis=0, join='outer')
print(concatenated_df)
'''
A B C D E
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
0 NaN NaN NaN NaN D4
1 NaN NaN NaN NaN D5
2 NaN NaN NaN NaN D6
3 NaN NaN NaN NaN D7
'''
为避免如上所示的索引重复（从 0 到 3 的索引在串联数据框中出现两次），请使用如下所示的 ignore_index=True。
concatenated_df = pd.concat([df1, df2], axis=0,ignore_index = True, join='outer')
print(concatenated_df)
'''
A B C D E
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
2 A2 B2 C2 D2 NaN
3 A3 B3 C3 D3 NaN
4 NaN NaN NaN NaN D4
5 NaN NaN NaN NaN D5
6 NaN NaN NaN NaN D6
7 NaN NaN NaN NaN D7
'''
3. join
语法：
join(self, other, on=None, how='left', lsuffix='', rsuffix='',sort=False):
其参数的意义与merge方法中的参数意义基本一样。该方法最为简单，主要用于索引上的合并。
3.1 正常的索引连接
df1 = pd.DataFrame(
{
"A": ["A0", "A1", "A2", "A3"],
"B": ["B0", "B1", "B2", "B3"],
"C": ["C0", "C1", "C2", "C3"],
"D": ["D0", "D1", "D2", "D3"],
},
index=[0, 1, 2, 3],
)
df2 = pd.DataFrame(
{
"E": ["D4", "D5", "D6", "D7"],
},
index=[0, 1, 2, 3],
)
# 默认 how="left"
join_df = df1.join(df2)
print(join_df)
'''
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
2 A2 B2 C2 D2 D6
3 A3 B3 C3 D3 D7
'''
3.2 多对一的索引连接
在这里可以看到能达到merge效果
df1 = pd.DataFrame(
{
"A": ["A0", "A1", "A2", "A3"],
"B": ["B0", "B1", "B2", "B3"],
"C": ["C0", "C1", "C2", "C3"],
"D": ["D0", "D1", "D2", "D3"],
},
index=[0, 1, 1, 1],
)
df2 = pd.DataFrame(
{
"E": ["D4", "D5", "D6", "D7"],
},
index=[0, 1, 2, 3],
)
# 默认 how="left"
join_df = df1.join(df2)
print(join_df)
'''
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
1 A2 B2 C2 D2 D5
1 A3 B3 C3 D3 D5
'''
3.3 索引有共同也有独立
df1 = pd.DataFrame(
{
"A": ["A0", "A1", "A2", "A3"],
"B": ["B0", "B1", "B2", "B3"],
"C": ["C0", "C1", "C2", "C3"],
"D": ["D0", "D1", "D2", "D3"],
},
index=[0, 1, 1, 4],
)
df2 = pd.DataFrame(
{
"E": ["D4", "D5", "D6", "D7"],
},
index=[0, 1, 2, 3],
)
# 默认 how="left"
join_df = df1.join(df2,how='outer')
print(join_df)
'''
A B C D E
0 A0 B0 C0 D0 D4
1 A1 B1 C1 D1 D5
1 A2 B2 C2 D2 D5
2 NaN NaN NaN NaN D6
3 NaN NaN NaN NaN D7
4 A3 B3 C3 D3 NaN
'''
# 测试concat
print(pd.concat([df1, df2]))
'''
A B C D E
0 A0 B0 C0 D0 NaN
1 A1 B1 C1 D1 NaN
1 A2 B2 C2 D2 NaN
4 A3 B3 C3 D3 NaN
0 NaN NaN NaN NaN D4
1 NaN NaN NaN NaN D5
2 NaN NaN NaN NaN D6
3 NaN NaN NaN NaN D7
'''
print(pd.concat([df1, df2],join='inner'))
''' 空数据
Empty DataFrame
Columns: []
Index: [0, 1, 1, 4, 0, 1, 2, 3]
'''
3.4 利用列为索引
df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value': [5, 6, 7, 8]})
joined_df = df1.join(df2.set_index('key'), on='key', how='outer', rsuffix='_y')
print(joined_df)
'''
key value value_y
0.0 A 1.0 NaN
1.0 B 2.0 5.0
2.0 C 3.0 NaN
3.0 D 4.0 6.0
NaN E NaN 7.0
NaN F NaN 8.0
'''
4. 总结
注：只有merge和join才能对应索引连接，并且索引是多对一关系
-
1、
join最简单，主要用于基于索引的横向合并拼接 -
2、
merge最常用，主要用于基于指定列的横向合并拼接,也可以用于索引合并。 -
3、
concat最强大，可用于横向和纵向合并拼接
concat函数和merge函数表连接的区别是：
1、concat函数既可以实现横向拼接也可以实现纵向拼接，merge函数只能进行横向连接
2、concat函数可以对多表进行操作，merge函数只能操作两张表
3、concat函数只能单纯的表拼接，只按索引拼接不查找公共列，merge可以按照键进行拼接。
可以看到，使用join方法得到的结果与使用merge方法得到的结果相同。不同之处在于，使用join方法时需要先将一个数据集的索引设置为要合并的列，而使用merge方法时则需要指定要合并的列名。
网友评论