python - Pandas 合并 101

Question

我该如何执行 ( INNER | ( LEFT | | RIGHT | | FULL ) OUTER ) JOIN和 Pandas ？

合并后如何为丢失的行添加 NaN？

合并后如何摆脱NaN？

我可以在索引上合并吗？

如何合并多个数据帧？

与 Pandas 交叉连接

merge ? join ? concat ? update ? WHO？什么？为什么？!

... 和更多。我已经看到这些反复出现的问题询问 Pandas 合并功能的各个方面。今天关于合并及其各种用例的大部分信息都分散在数十个措辞恶劣、无法搜索的帖子中。这里的目的是为后代整理一些更重要的观点。
本问答旨在成为一系列有关 Pandas 常用习语的有用用户指南的下一部分(请参阅 this post on pivoting 和 this post on concatenation ，稍后我将对此进行介绍)。
请注意，这篇文章并不能替代 the documentation ，所以也请阅读!一些例子取自那里。

目录
为了方便访问。

Merging basics - basic types of joins (先读这个)

Index-based joins

Generalizing to multiple DataFrames

Cross join

Answer 1

这篇文章旨在向读者介绍 SQL 风格的 Pandas 合并、如何使用它以及何时不使用它。
特别是，这是这篇文章将要经历的:

基础知识 - 连接类型(LEFT、RIGHT、OUTER、INNER)

合并不同的列名

与多列合并

避免输出中重复的合并键列

这篇文章(以及我在这个线程上的其他帖子)不会通过:

与性能相关的讨论和时间安排(目前)。在适当的地方，主要提到了更好的替代方案。

处理后缀、删除额外的列、重命名输出和其他特定用例。还有其他(阅读:更好)的帖子可以解决这个问题，所以弄清楚!

NoteMost examples default to INNER JOIN operations while demonstrating various features, unless otherwise specified.

Furthermore, all the DataFrames here can be copied and replicated soyou can play with them. Also, see thisposton how to read DataFrames from your clipboard.

Lastly, all visual representation of JOIN operations have been hand-drawn using Google Drawings. Inspiration from here.

废话不多说 - 告诉我如何使用 merge !
设置和基础

np.random.seed(0)
left = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': np.random.randn(4)})
right = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value': np.random.randn(4)})

left

  key     value
0   A  1.764052
1   B  0.400157
2   C  0.978738
3   D  2.240893

right

  key     value
0   B  1.867558
1   D -0.977278
2   E  0.950088
3   F -0.151357

为简单起见，键列具有相同的名称(暂时)。
安 内连接由

NoteThis, along with the forthcoming figures all follow this convention:

• blue indicates rows that are present in the merge result
• red indicates rows that are excluded from the result (i.e., removed)
• green indicates missing values that are replaced with NaNs in the result

要执行 INNER JOIN，请调用 merge 在左侧 DataFrame 上，指定右侧 DataFrame 和连接键(至少)作为参数。

left.merge(right, on='key')
# Or, if you want to be explicit
# left.merge(right, on='key', how='inner')

  key   value_x   value_y
0   B  0.400157  1.867558
1   D  2.240893 -0.977278

这仅返回来自 left 的行和 right共享一个公共(public) key (在本例中为“B”和“D”)。
A 左外连接 , 或 LEFT JOIN 表示为

这可以通过指定 how='left' 来执行。 .

left.merge(right, on='key', how='left')

  key   value_x   value_y
0   A  1.764052       NaN
1   B  0.400157  1.867558
2   C  0.978738       NaN
3   D  2.240893 -0.977278

请仔细注意此处 NaN 的位置。如果您指定 how='left' ，然后只有来自 left 的 key 使用，并且缺少来自 right 的数据被 NaN 取代。
同样，对于 右外连接 , 或 RIGHT JOIN 这是...

...指定 how='right' :

left.merge(right, on='key', how='right')

  key   value_x   value_y
0   B  0.400157  1.867558
1   D  2.240893 -0.977278
2   E       NaN  0.950088
3   F       NaN -0.151357

在这里，来自 right 的 key 使用，并且缺少来自 left 的数据被 NaN 取代。
最后，对于 全外连接 ，由

指定 how='outer' .

left.merge(right, on='key', how='outer')

  key   value_x   value_y
0   A  1.764052       NaN
1   B  0.400157  1.867558
2   C  0.978738       NaN
3   D  2.240893 -0.977278
4   E       NaN  0.950088
5   F       NaN -0.151357

这使用来自两个帧的键，并为两者中缺失的行插入 NaN。
文档很好地总结了这些不同的合并:


其他联接 - 左排除、右排除和完全排除/反联接
如果您需要 LEFT-排除连接 和 RIGHT-排除连接 分两步。
对于 LEFT-Exclusion JOIN，表示为

首先执行 LEFT OUTER JOIN，然后过滤(排除!)来自 left 的行只要，

(left.merge(right, on='key', how='left', indicator=True)
     .query('_merge == "left_only"')
     .drop('_merge', 1))

  key   value_x  value_y
0   A  1.764052      NaN
2   C  0.978738      NaN

在哪里，

left.merge(right, on='key', how='left', indicator=True)

  key   value_x   value_y     _merge
0   A  1.764052       NaN  left_only
1   B  0.400157  1.867558       both
2   C  0.978738       NaN  left_only
3   D  2.240893 -0.977278       both

同样，对于 RIGHT-Excluded JOIN，

(left.merge(right, on='key', how='right', indicator=True)
     .query('_merge == "right_only"')
     .drop('_merge', 1))

  key  value_x   value_y
2   E      NaN  0.950088
3   F      NaN -0.151357

最后，如果您需要进行合并，只保留左侧或右侧的键，但不能同时保留两者(IOW，执行 ANTI-JOIN )，

你可以用类似的方式做到这一点——

(left.merge(right, on='key', how='outer', indicator=True)
     .query('_merge != "both"')
     .drop('_merge', 1))

  key   value_x   value_y
0   A  1.764052       NaN
2   C  0.978738       NaN
4   E       NaN  0.950088
5   F       NaN -0.151357

键列的不同名称
如果键列的名称不同，例如 left有 keyLeft , 和 right有 keyRight而不是 key — 那么你必须指定 left_on和 right_on作为参数而不是 on :

left2 = left.rename({'key':'keyLeft'}, axis=1)
right2 = right.rename({'key':'keyRight'}, axis=1)

left2

  keyLeft     value
0       A  1.764052
1       B  0.400157
2       C  0.978738
3       D  2.240893

right2

  keyRight     value
0        B  1.867558
1        D -0.977278
2        E  0.950088
3        F -0.151357

left2.merge(right2, left_on='keyLeft', right_on='keyRight', how='inner')

  keyLeft   value_x keyRight   value_y
0       B  0.400157        B  1.867558
1       D  2.240893        D -0.977278

避免输出中的重复键列
在 keyLeft 上合并时来自 left和 keyRight来自 right ，如果您只想要 keyLeft 中的任何一个或 keyRight (但不是两者)在输出中，您可以首先将索引设置为初步步骤。

left3 = left2.set_index('keyLeft')
left3.merge(right2, left_index=True, right_on='keyRight')

    value_x keyRight   value_y
0  0.400157        B  1.867558
1  2.240893        D -0.977278

将此与之前命令的输出(即 left2.merge(right2, left_on='keyLeft', right_on='keyRight', how='inner') 的输出)进行对比，您会注意到 keyLeft不见了。您可以根据将哪个帧的索引设置为键来确定要保留的列。例如，在执行某些 OUTER JOIN 操作时，这可能很重要。

仅合并来自 DataFrames 之一的单个列
例如，考虑

right3 = right.assign(newcol=np.arange(len(right)))
right3
  key     value  newcol
0   B  1.867558       0
1   D -0.977278       1
2   E  0.950088       2
3   F -0.151357       3

如果您只需要合并“new_val”(没有任何其他列)，您通常可以在合并之前对列进行子集:

left.merge(right3[['key', 'newcol']], on='key')

  key     value  newcol
0   B  0.400157       0
1   D  2.240893       1

如果您正在执行左外连接，则性能更高的解决方案将涉及 map :

# left['newcol'] = left['key'].map(right3.set_index('key')['newcol']))
left.assign(newcol=left['key'].map(right3.set_index('key')['newcol']))

  key     value  newcol
0   A  1.764052     NaN
1   B  0.400157     0.0
2   C  0.978738     NaN
3   D  2.240893     1.0

如前所述，这类似于，但比

left.merge(right3[['key', 'newcol']], on='key', how='left')

  key     value  newcol
0   A  1.764052     NaN
1   B  0.400157     0.0
2   C  0.978738     NaN
3   D  2.240893     1.0

多列合并
要加入多个列，请为 on 指定一个列表(或 left_on 和 right_on ，视情况而定)。

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

或者，如果名称不同，

left.merge(right, left_on=['lkey1', 'lkey2'], right_on=['rkey1', 'rkey2'])

其他有用的 merge*操作和功能

将 DataFrame 与索引上的系列合并:参见 this answer .

除了merge , DataFrame.update 和 DataFrame.combine_first 在某些情况下也用于将一个 DataFrame 更新为另一个。

pd.merge_ordered 是有序 JOIN 的有用函数。

pd.merge_asof (阅读:merge_asOf)对于近似连接很有用。

本节仅涵盖非常基础的内容，旨在满足您的胃口。有关更多示例和案例，请参阅 documentation on merge , join , and concat 以及功能规范的链接。

继续阅读
跳转到 Pandas Merging 101 中的其他主题以继续学习:

Merging basics - basic types of joins *

Index-based joins

Generalizing to multiple DataFrames

Cross join

*你在这里。