inner join 和join的区别_pandas中concat(), append(), merge()的区别和用法

文章目录

• 三个函数的区别
  • concat()
  • append()
  • merge()
• 三个函数各自的拓展用法
  • concat()
    • 连接多个DataFrame
    • 设置特定的键（key）
    • 横向合并两个DataFrame
  • append()
    • 连接多个DataFrame
  • merge()
    • 指定两个列名连接DataFrame
    • merge()的四种连接方式

1. 三个函数的区别

concat(), append(), merge()一般都是用来连接两个或者多个DataFrame对象。其中， concat(), append()默认用来纵向连接DataFrame对象， merge()用来横向连接DataFrame对象。

接下来我们来看看具体的例子。

1.1 concat()

concat()默认情况下是纵向连接两个DataFrame：

# 初始化df1
 

# 初始化df2
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                        'C': ['C4', 'C5', 'C6', 'C7'],
                        'D': ['D4', 'D5', 'D6', 'D7']})
df2

# concat : 纵向连接df1和df2。
result = pd.concat([df1, df2])
result

我们看到df1, df2纵向合并在了一起。但也注意到， 因为concat()保留了每个子DataFrame的index， 所以合并之后的DataFrame中， 每个index出现了两次。

我们可以通过设置ignore_index=False来解决这个问题：

result = pd.concat([df1, df2], ignore_index=True)
result

可以看到， 设置了ignore_index=True之后， 合并之后的DataFrame对index重新进行了排序。

1.2 append()

append()的默认操作效果跟concat()相同， 都是实现两个DataFrame的纵向连接。事实上可以把它看做concat()的早期版本：

 df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
 df1

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                        'C': ['C4', 'C5', 'C6', 'C7'],
                        'D': ['D4', 'D5', 'D6', 'D7']})
df2

result = df1.append(df2)
result

可以看到我们得到了跟concat()默认操作同样的结果。因为append()也保留了每个子DataFrame的index， 所以合并之后的DataFrame中， 每个index出现了两次。

我们同样可以通过设置ignore_index=False来解决这个问题：

result = df1.append(df2, ignore_index=True)
result

1.3 merge()

merge()的默认操作是横向连接两个DataFrame对象：

left = pd.DataFrame({'key': ['K0', 'K1', 'K2'],
                     'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']})
left

right = pd.DataFrame({'key': ['K1', 'K2', 'K3'],
                       'C': ['C1', 'C2', 'C3'],
                       'D': ['D1', 'D2', 'D3']}) 
right

#  横向合并left和right两个子DataFrame。
## on='key' :  把两个子DataFrame中key列相同的值连接到一行上。
result = pd.merge(left, right, ｏｎ='key')
result

从上面的结果可以看出， merge()方法把两个子DataFrame中key列相同的值连接到了一行上， 并且删去了key列值不相同的行。

如果想保留key列值不相同的行， 可以添加上how='outer'参数：

# how: 指定两个子DataFrame的连接方式， 
result = pd.merge(left, right, on='key', how='outer')
result

2. 三个函数各自的拓展用法

2.1 concat()

• 2.1.1 连接多个DataFrame

concat()可以一次性连接3个或者3个以上的DataFrame：

 df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
 df1

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                        'C': ['C4', 'C5', 'C6', 'C7'],
                        'D': ['D4', 'D5', 'D6', 'D7']})
df2

df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                     'B': ['B8', 'B9', 'B10', 'B11'],
                      'C': ['C8', 'C9', 'C10', 'C11'],
                      'D': ['D8', 'D9', 'D10', 'D11']})
df3

result = pd.concat([df1, df2, df3])
result

• 2.1.2 设置特定的键（key）

有时候我们需要区分合并之后的DataFrame里， 哪些数据是来自df1的，哪些数据是来自df2的。这个时候我们可以给它们设置一个特定的键（key）， 相当于给它们起个名字， 这样我们就可以把它们区分开来了。

# 为每个子DataFrame设置一个特定的键（key）
result = pd.concat([df1, df2], keys=['df1', 'df2'])
result

可以看到， 在合并后的DataFrame里， 我们用key把每个子DataFrame的数据标识了出来。

我们可以通过下面的方式取用某个子DataFrame的数据：

result.loc['df1']

• 2.1.3 横向合并两个DataFrame

默认情况下， concat()纵向合并两个子DataFrame， 但通过设置axis=1参数之后， 我们也可以横向合并两个DataFrame。

 df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
 df1

# 准备一组新的数据df4
df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
                     'D': ['D2', 'D3', 'D6', 'D7'],
                     'F': ['F2', 'F3', 'F6', 'F7']},
                    index=[2, 3, 6, 7])
df4

result = pd.concat([df1, df4], axis=1)
result

从上面的结果可以看到， 设置了axis=1之后， df1和df4两个DataFrame横向地结合在了一起。两个DataFrame有着相同index的行连成了一行， index不相同的行各自占一行的内容。

如果只想保留有着相同index的行， 可以添加上join=‘inner’参数：

result = pd.concat([df1, df4], axis=1, join='inner')
result

如果想保留某个子DataFrame的index所在的行， 比如df1中index为0-3的行， 可以加上join_axes=[df1.index]参数：

result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
result

2.2 append()

• 2.2.1 连接多个DataFrame

和concat()一样， append()也可以一次性连接3个或者3个以上的DataFrame：

 df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']})
 df1

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                        'C': ['C4', 'C5', 'C6', 'C7'],
                        'D': ['D4', 'D5', 'D6', 'D7']})
df2merge()

df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                     'B': ['B8', 'B9', 'B10', 'B11'],
                      'C': ['C8', 'C9', 'C10', 'C11'],
                      'D': ['D8', 'D9', 'D10', 'D11']})
df3

result = df1.append([df2, df3])
result

2.3 merge()

• 2.3.1 指定两个列名连接DataFrame

我们可以在on参数里指定两个或者两个以上的列名对DataFrame进行连接:

left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                         'key2': ['K0', 'K1', 'K0', 'K1'],
                         'A': ['A0', 'A1', 'A2', 'A3'],
                         'B': ['B0', 'B1', 'B2', 'B3']})
left

right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                          'key2': ['K0', 'K0', 'K0', 'K0'],
                          'C': ['C0', 'C1', 'C2', 'C3'],
                          'D': ['D0', 'D1', 'D2', 'D3']})
right

result = pd.merge(left, right, on=['key1', 'key2'])
result

在上面的例子里， 我们在on参数里设置了key1， key2两个值， 于是在连接left和right两个DataFrame的时候， 会把key1, key2都相等的行连在一起， 而key1, key2不完全相等的行则会被舍弃掉。

• 2.3.2 merge()的四种连接方式

merge()的how参数可以设置DataFrame的四种连接方式：左连接(left), 右连接(right), 外连接(outer), 内连接(inner)。

内连接(inner)是merge()的默认连接方式， 当how中不设置任何参数的时候， merge()用的是内连接(inner)方式。 也就是我们在上面的例子中所看到的， key值不完全相同的行便不会显示在最终的结果里 :

left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                         'key2': ['K0', 'K1', 'K0', 'K1'],
                         'A': ['A0', 'A1', 'A2', 'A3'],
                         'B': ['B0', 'B1', 'B2', 'B3']})
left

right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                          'key2': ['K0', 'K0', 'K0', 'K0'],
                          'C': ['C0', 'C1', 'C2', 'C3'],
                          'D': ['D0', 'D1', 'D2', 'D3']})
right

result = pd.merge(left, right, on=['key1', 'key2'],
                 how='inner')
result

外连接(outer)则会保留两个DataFrame中所有的行：

result = pd.merge(left, right, on=['key1', 'key2'],
                  how='outer')
result

左连接(left)则会保留左边的子DataFrame中所有的行：

result = pd.merge(left, right, on=['key1', 'key2'],
                  how='left')
result

右连接(right)则会保留右边的子DataFrame中所有的行：

result = pd.merge(left, right, on=['key1', 'key2'],
                  how='right')
result

以上便是本篇文章的内容。

参考资料：

https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html