问：

如何执行（|(||)）和熊猫？INNERLEFTRIGHTFULLOUTERJOIN
如何为合并后缺失的行添加 NaN？
合并后如何摆脱 NaN？
我可以在索引上合并吗？
如何合并多个 DataFrame？
与熊猫交叉连接
merge? ? ? ?谁？什么？为什么？！joinconcatupdate

...和更多。我已经看到这些反复出现的问题，询问熊猫合并功能的各个方面。今天，关于合并及其各种用例的大多数信息都分散在数十个措辞不当、无法搜索的帖子中。这里的目的是为后代整理一些更重要的观点。

本问答是一系列关于常见熊猫习语的有用用户指南中的下一部分（请参阅这篇关于枢轴的文章，以及这篇关于串联的文章，我稍后会谈到）。

请注意，这篇文章并不是要替代文档，所以也请阅读！一些例子就是从那里取来的。

注意除非另有说明，否则大多数示例在演示各种功能时默认使用 INNER JOIN 操作。

此外，这里的所有数据帧都可以被复制和复制，因此你可以和他们一起玩。另外，请参阅此内容关于如何从剪贴板读取数据帧的帖子。

最后，JOIN 操作的所有视觉表示都是使用 Google 绘图手绘的。灵感来自这里。

说得够多了 - 只是告诉我如何使用！`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

为简单起见，键列具有相同的名称（目前）。

INNER JOIN 表示为

注意这与即将到来的数字一起都遵循以下惯例：

蓝色表示合并结果中存在的行

红色表示从结果中排除的行（即删除）

绿色表示结果中替换为 S 的缺失值NaN

要执行 INNER JOIN，请在左侧 DataFrame 上调用 merge，将右侧 DataFrame 和 join 键（至少）指定为参数。

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

这仅返回共享公共键的行（在本例中为“B”和“D”）。leftright

左外连接或左连接由下式表示

这可以通过指定来执行。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 在此处的位置。如果指定，则仅使用 from 键，而缺少的数据 from 将替换为 NaN。how='left'leftright

同样，对于右外连接，或右连接，这是......

...指定：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

这里，使用了 from 键，而缺少的数据 from 被 NaN 替换。rightleft

最后，对于 FULL OUTER JOIN，由

指定。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。

该文档很好地总结了这些不同的合并：

其他 JOIN - LEFT-Excluding、RIGHT-Excluding 和 FULL-Excluding/ANTI JOIN

如果您需要 LEFT-Exclude JOIN 和 RIGHT-Exclude JOINs 分两步完成。

对于 LEFT - 排除 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-Exclude 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

键列的不同名称

如果键列的命名方式不同（例如，有和 has 而不是），则必须将和指定为参数，而不是：leftkeyLeftrightkeyRightkeyleft_onright_onon

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

避免输出中出现重复的键列

合并 from 和 from 时，如果只想在输出中加入 or（但不能同时使用两者），则可以先将索引设置为预备步骤。keyLeftleftkeyRightrightkeyLeftkeyRight

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

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

仅合并其中一个 `DataFrame` 中的一列

例如，考虑

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

如果只需要合并“newcol”（不合并任何其他列），则通常可以在合并之前只对列进行子集：

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

  key     value  newcol
0   B  0.400157       0
1   D  2.240893       1

如果您正在执行 LEFT OUTER JOIN，则性能更高的解决方案将涉及：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

合并多个列

若要联接多个列，请指定的列表（或和，视情况而定）。onleft_onright_on

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

或者，如果名称不同，

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

**其他有用的`合并*` 操作和函数**

将 DataFrame 与索引上的 Series 合并：请参阅此答案。
此外，DataFrame.update 和 DataFrame.combine_first 在某些情况下也用于将一个 DataFrame 更新为另一个 DataFrame。merge
pd.merge_ordered 对于有序 JOIN 来说是一个有用的函数。
pd.merge_asof（读作：merge_asOf）对于近似联接很有用。

本节仅涵盖最基本的内容，旨在激发您的食欲。有关更多示例和案例，请参阅有关合并、连接和连接的文档以及函数规范的链接。

继续阅读

跳转至 Pandas Merging 101 中的其他主题以继续学习：

_{*你在这里。}

Google Doc 内置的“插入 ==> 绘图... ==> 新”（截至 2019 年 5 月）。但是，需要明确的是：我使用谷歌文档制作这张图片的唯一原因是因为我的笔记存储在谷歌文档中，我想要一张可以在谷歌文档本身中快速修改的图片。实际上现在你提到了它，谷歌文档的绘图工具非常简洁。

2赞 Ufos 8/1/2019

哇，这太棒了。来自 SQL 世界，“垂直”联接在我的脑海中并不是一个联接，因为表的结构始终是固定的。现在甚至认为熊猫应该合并，并且方向参数为或 .concatmergehorizontalvertical

4赞 cs95 8/7/2019

@Ufos 这不正是是什么吗？axis=1axis=0

5赞 Ufos 8/19/2019

是的，现在有和轴心等等。然而，正如@eliu所示，这与“左”和“右”以及“水平”或“垂直”的合并概念相同。就我个人而言，每次我必须记住哪个“轴”是哪个“轴”，哪个是.mergeconcat01

26赞 Gonçalo Peres 8/10/2020 #4

在这个答案中，我将考虑以下实际例子：

pandas.concat
熊猫。DataFrame.merge 合并一个 DataFrame 索引和另一个 Column 的数据帧。

我们将对每种情况使用不同的数据帧。

1. 熊猫.concat

使用相同的列名考虑以下事项：DataFrames

价格2018与尺寸(8784, 5)

   Year  Month  Day  Hour  Price
0  2018      1    1     1   6.74
1  2018      1    1     2   4.74
2  2018      1    1     3   3.66
3  2018      1    1     4   2.30
4  2018      1    1     5   2.30
5  2018      1    1     6   2.06
6  2018      1    1     7   2.06
7  2018      1    1     8   2.06
8  2018      1    1     9   2.30
9  2018      1    1    10   2.30

价格2019与尺寸(8760, 5)

   Year  Month  Day  Hour  Price
0  2019      1    1     1  66.88
1  2019      1    1     2  66.88
2  2019      1    1     3  66.00
3  2019      1    1     4  63.64
4  2019      1    1     5  58.85
5  2019      1    1     6  55.47
6  2019      1    1     7  56.00
7  2019      1    1     8  61.09
8  2019      1    1     9  61.01
9  2019      1    1    10  61.00

可以使用 pandas.concat 将它们组合在一起，只需

import pandas as pd

frames = [Price2018, Price2019]

df_merged = pd.concat(frames)

这会导致 DataFrame 的大小(17544, 5)

如果一个人想清楚地了解发生了什么，它的工作方式是这样的

(源)

2.熊猫。数据帧.merge

在本节中，我们将考虑一个特定情况：合并一个 DataFrame 的索引和另一个 DataFrame 的列。

假设有一个带有列的数据帧，它是的列之一，其类型为。Geo54Datedatetime64[ns]

                 Date         1         2  ...        51        52        53
0 2010-01-01 00:00:00  0.565919  0.892376  ...  0.593049  0.775082  0.680621
1 2010-01-01 01:00:00  0.358960  0.531418  ...  0.734619  0.480450  0.926735
2 2010-01-01 02:00:00  0.531870  0.221768  ...  0.902369  0.027840  0.398864
3 2010-01-01 03:00:00  0.475463  0.245810  ...  0.306405  0.645762  0.541882
4 2010-01-01 04:00:00  0.954546  0.867960  ...  0.912257  0.039772  0.627696

并且具有一列价格的 DataFrame，索引对应于日期（PricePriceDate)

                     Price
Date                      
2010-01-01 00:00:00  29.10
2010-01-01 01:00:00   9.57
2010-01-01 02:00:00   0.00
2010-01-01 03:00:00   0.00
2010-01-01 04:00:00   0.00

为了合并它们，可以使用 pandas。DataFrame.merge 如下

df_merged = pd.merge(Price, Geo, left_index=True, right_on='Date')

其中和是以前的数据帧。GeoPrice

这将产生以下数据帧

   Price                Date         1  ...        51        52        53
0  29.10 2010-01-01 00:00:00  0.565919  ...  0.593049  0.775082  0.680621
1   9.57 2010-01-01 01:00:00  0.358960  ...  0.734619  0.480450  0.926735
2   0.00 2010-01-01 02:00:00  0.531870  ...  0.902369  0.027840  0.398864
3   0.00 2010-01-01 03:00:00  0.475463  ...  0.306405  0.645762  0.541882
4   0.00 2010-01-01 04:00:00  0.954546  ...  0.912257  0.039772  0.627696

16赞 7 revs, 3 users 85%cs95 #5

这篇文章将讨论以下主题：

如何正确地泛化到多个 DataFrame（以及为什么这里有缺点）merge
合并唯一键
合并非唯一键

_返回页首

泛化为多个 DataFrame

通常，当多个 DataFrame 要合并在一起时会出现这种情况。幼稚地，这可以通过链接调用来完成：merge

df1.merge(df2, ...).merge(df3, ...)

但是，对于许多 DataFrame 来说，这很快就会失控。此外，可能需要对未知数量的 DataFrame 进行泛化。

在这里，我将介绍对唯一键的多向联接，以及对非唯一键的多向联接。首先，设置。pd.concatDataFrame.join

# Setup.
np.random.seed(0)
A = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'valueA': np.random.randn(4)})    
B = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'valueB': np.random.randn(4)})
C = pd.DataFrame({'key': ['D', 'E', 'J', 'C'], 'valueC': np.ones(4)})
dfs = [A, B, C] 

# Note: the "key" column values are unique, so the index is unique.
A2 = A.set_index('key')
B2 = B.set_index('key')
C2 = C.set_index('key')

dfs2 = [A2, B2, C2]

唯一键上的多路合并

如果您的键（此处的键可以是列或索引）是唯一的，则可以使用 .请注意，pd.concat 在索引上联接 DataFrames。pd.concat

# Merge on `key` column. You'll need to set the index before concatenating
pd.concat(
    [df.set_index('key') for df in dfs], axis=1, join='inner'
).reset_index()

  key    valueA    valueB  valueC
0   D  2.240893 -0.977278     1.0

# Merge on `key` index.
pd.concat(dfs2, axis=1, sort=False, join='inner')

       valueA    valueB  valueC
key                            
D    2.240893 -0.977278     1.0

省略 FULL OUTER JOIN。请注意，不能指定 LEFT 或 RIGHT OUTER 连接（如果需要这些连接，请使用，如下所述）。join='inner'join

对具有重复项的键进行多路合并

concat速度快，但有其缺点。它不能处理重复项。

A3 = pd.DataFrame({'key': ['A', 'B', 'C', 'D', 'D'], 'valueA': np.random.randn(5)})
pd.concat([df.set_index('key') for df in [A3, B, C]], axis=1, join='inner')

ValueError: Shape of passed values is (3, 4), indices imply (3, 2)

在这种情况下，我们可以使用，因为它可以处理非唯一键（请注意，在索引上连接 DataFrame;除非另有说明，否则它会在后台调用并执行 LEFT OUTER JOIN）。joinjoinmerge

# Join on `key` column. Set as the index first.
# For inner join. For left join, omit the "how" argument.
A.set_index('key').join([B2, C2], how='inner').reset_index()

  key    valueA    valueB  valueC
0   D  2.240893 -0.977278     1.0

# Join on `key` index.
A3.set_index('key').join([B2, C2], how='inner')

       valueA    valueB  valueC
key                            
D    1.454274 -0.977278     1.0
D    0.761038 -0.977278     1.0

继续阅读

跳转至 Pandas Merging 101 中的其他主题以继续学习：

_{* 你在这里}

18赞 6 revs, 2 users 100%cs95 #6

这篇文章将讨论以下主题：

不同条件下与索引合并
- 基于索引的联接选项：、、mergejoinconcat
- 合并索引
- 合并一个索引，合并其他列
有效地使用命名索引来简化合并语法

_返回页首

基于索引的联接

TL;博士

有几个选项，有些比其他选项更简单，具体取决于用途箱。

DataFrame.merge 与和（或和使用命名索引）left_indexright_indexleft_onright_on

支持内/左/右/全

一次只能加入两个

支持列-列、索引-列、索引-索引联接

DataFrame.join（在索引上联接）

支持内部/左（默认）/右/全

一次可以联接多个 DataFrame

支持索引-索引连接

pd.concat（在索引上联接）

支持 inner/full（默认）

一次可以联接多个 DataFrame

支持索引-索引连接

索引到索引联接

设置和基础知识

import pandas as pd
import numpy as np

np.random.seed([3, 14])
left = pd.DataFrame(data={'value': np.random.randn(4)}, 
                    index=['A', 'B', 'C', 'D'])    
right = pd.DataFrame(data={'value': np.random.randn(4)},  
                     index=['B', 'D', 'E', 'F'])
left.index.name = right.index.name = 'idxkey'

left
           value
idxkey          
A      -0.602923
B      -0.402655
C       0.302329
D      -0.524349

right
 
           value
idxkey          
B       0.543843
D       0.013135
E      -0.326498
F       1.385076

通常，索引上的内部连接如下所示：

left.merge(right, left_index=True, right_index=True)

         value_x   value_y
idxkey                    
B      -0.402655  0.543843
D      -0.524349  0.013135

其他联接遵循类似的语法。

值得注意的替代品

DataFrame.join 默认为索引上的联接。默认情况下执行 LEFT OUTER JOIN，因此这里是必要的。DataFrame.joinhow='inner'

 left.join(right, how='inner', lsuffix='_x', rsuffix='_y')

          value_x   value_y
 idxkey                    
 B      -0.402655  0.543843
 D      -0.524349  0.013135

请注意，我需要指定 and 参数，否则会出错：lsuffixrsuffixjoin

 left.join(right)
 ValueError: columns overlap but no suffix specified: Index(['value'], dtype='object')

由于列名相同。如果它们的名称不同，这将不是问题。

 left.rename(columns={'value':'leftvalue'}).join(right, how='inner')

         leftvalue     value
 idxkey                     
 B       -0.402655  0.543843
 D       -0.524349  0.013135

pd.concat 联接索引，可以同时联接两个或多个 DataFrame。默认情况下，它执行完整的外部连接，因此此处是必需的。how='inner'
```
 pd.concat([left, right], axis=1, sort=False, join='inner')

            value     value
 idxkey                    
 B      -0.402655  0.543843
 D      -0.524349  0.013135
```
有关更多信息，请参阅此帖子。concat

列联接的索引

要使用左索引和右列的索引执行内部连接，您将使用和的组合。DataFrame.mergeleft_index=Trueright_on=...

right2 = right.reset_index().rename({'idxkey' : 'colkey'}, axis=1)
right2
 
  colkey     value
0      B  0.543843
1      D  0.013135
2      E -0.326498
3      F  1.385076

left.merge(right2, left_index=True, right_on='colkey')

    value_x colkey   value_y
0 -0.402655      B  0.543843
1 -0.524349      D  0.013135

其他联接也遵循类似的结构。请注意，只能执行列联接的索引。您可以联接多个列，前提是左侧的索引级别数等于右侧的列数。merge

join并且不能进行混合合并。您需要使用 DataFrame.set_index 将索引设置为预步骤。concat

有效使用命名索引 [pandas >= 0.23]

如果索引已命名，则 from pandas >= 0.23 允许您将索引名称指定为（或和根据需要）。DataFrame.mergeonleft_onright_on

left.merge(right, on='idxkey')

         value_x   value_y
idxkey                    
B      -0.402655  0.543843
D      -0.524349  0.013135

对于前面的示例，与左边的索引合并，右边的列，您可以使用左边的索引名称：left_on

left.merge(right2, left_on='idxkey', right_on='colkey')

    value_x colkey   value_y
0 -0.402655      B  0.543843
1 -0.524349      D  0.013135

继续阅读

跳转至 Pandas Merging 101 中的其他主题以继续学习：

_{* 你在这里}

76赞 Anurag Dhadse 9/9/2021 #7

加入 101

这些动画可能更适合直观地解释您。学分：Garrick Aden-Buie tidyexplain repo

内部连接

外部连接或完全连接

右加入

左加入

2赞 sammywemmy 8/9/2022 #8

目前 Pandas 不支持合并语法中的不等式连接;一种选择是使用 pyjanitor 的 conditional_join 函数 - 我是这个库的贡献者：

# pip install pyjanitor
import pandas as pd
import janitor 

left.conditional_join(right, ('value', 'value', '>'))

   left           right
    key     value   key     value
0     A  1.764052     D -0.977278
1     A  1.764052     F -0.151357
2     A  1.764052     E  0.950088
3     B  0.400157     D -0.977278
4     B  0.400157     F -0.151357
5     C  0.978738     D -0.977278
6     C  0.978738     F -0.151357
7     C  0.978738     E  0.950088
8     D  2.240893     D -0.977278
9     D  2.240893     F -0.151357
10    D  2.240893     E  0.950088
11    D  2.240893     B  1.867558

left.conditional_join(right, ('value', 'value', '<'))

  left           right
   key     value   key     value
0    A  1.764052     B  1.867558
1    B  0.400157     E  0.950088
2    B  0.400157     B  1.867558
3    C  0.978738     B  1.867558

这些列作为元组的变量参数传递，每个元组由左侧数据帧中的一列、右侧数据帧中的一列和连接运算符组成，联接运算符可以是中的任何一个。在上面的示例中，由于列名重叠，因此返回了 MultiIndex 列。(>, <, >=, <=, !=)

在性能方面，这比朴素的交叉联接要好：

np.random.seed(0)
dd = pd.DataFrame({'value':np.random.randint(100000, size=50_000)})
df = pd.DataFrame({'start':np.random.randint(100000, size=1_000), 
                   'end':np.random.randint(100000, size=1_000)})

dd.head()

   value
0  68268
1  43567
2  42613
3  45891
4  21243

df.head()

   start    end
0  71915  47005
1  64284  44913
2  13377  96626
3  75823  38673
4  29151    575


%%timeit
out = df.merge(dd, how='cross')
out.loc[(out.start < out.value) & (out.end > out.value)]
5.12 s ± 19 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit df.conditional_join(dd, ('start', 'value' ,'<'), ('end', 'value' ,'>'))
280 ms ± 5.56 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit df.conditional_join(dd, ('start', 'value' ,'<'), ('end', 'value' ,'>'), use_numba=True)
124 ms ± 12.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

out = df.merge(dd, how='cross')
out = out.loc[(out.start < out.value) & (out.end > out.value)]
A = df.conditional_join(dd, ('start', 'value' ,'<'), ('end', 'value' ,'>'))
columns = A.columns.tolist()
A = A.sort_values(columns, ignore_index = True)
out = out.sort_values(columns, ignore_index = True)

A.equals(out)
True

根据数据大小，当存在 equi 联接时，您可以获得更高的性能。在这种情况下，使用 pandas 合并函数，但最终数据帧会延迟，直到计算出非等价连接。让我们从这里看一下数据：

import pandas as pd
import numpy as np
import random
import datetime

def random_dt_bw(start_date,end_date):
    days_between = (end_date - start_date).days
    random_num_days = random.randrange(days_between)
    random_dt = start_date + datetime.timedelta(days=random_num_days)
    return random_dt

def generate_data(n=1000):
    items = [f"i_{x}" for x in range(n)]
    start_dates = [random_dt_bw(datetime.date(2020,1,1),datetime.date(2020,9,1)) for x in range(n)]
    end_dates = [x + datetime.timedelta(days=random.randint(1,10)) for x in start_dates]
    
    offerDf = pd.DataFrame({"Item":items,
                            "StartDt":start_dates,
                            "EndDt":end_dates})
    
    transaction_items = [f"i_{random.randint(0,n)}" for x in range(5*n)]
    transaction_dt = [random_dt_bw(datetime.date(2020,1,1),datetime.date(2020,9,1)) for x in range(5*n)]
    sales_amt = [random.randint(0,1000) for x in range(5*n)]
    
    transactionDf = pd.DataFrame({"Item":transaction_items,"TransactionDt":transaction_dt,"Sales":sales_amt})

    return offerDf,transactionDf

offerDf,transactionDf = generate_data(n=100000)


offerDf = (offerDf
           .assign(StartDt = offerDf.StartDt.astype(np.datetime64), 
                   EndDt = offerDf.EndDt.astype(np.datetime64)
                  )
           )

transactionDf = transactionDf.assign(TransactionDt = transactionDf.TransactionDt.astype(np.datetime64))

# you can get more performance when using ints/datetimes
# in the equi join, compared to strings

offerDf = offerDf.assign(Itemr = offerDf.Item.str[2:].astype(int))

transactionDf = transactionDf.assign(Itemr = transactionDf.Item.str[2:].astype(int))

transactionDf.head()
      Item TransactionDt  Sales  Itemr
0  i_43407    2020-05-29    692  43407
1  i_95044    2020-07-22    964  95044
2  i_94560    2020-01-09    462  94560
3  i_11246    2020-02-26    690  11246
4  i_55974    2020-03-07    219  55974

offerDf.head()
  Item    StartDt      EndDt  Itemr
0  i_0 2020-04-18 2020-04-19      0
1  i_1 2020-02-28 2020-03-07      1
2  i_2 2020-03-28 2020-03-30      2
3  i_3 2020-08-03 2020-08-13      3
4  i_4 2020-05-26 2020-06-04      4

# merge on strings 
merged_df = pd.merge(offerDf,transactionDf,on='Itemr')
classic_int = merged_df[(merged_df['TransactionDt']>=merged_df['StartDt']) &
                        (merged_df['TransactionDt']<=merged_df['EndDt'])]

# merge on ints ... usually faster
merged_df = pd.merge(offerDf,transactionDf,on='Item')
classic_str = merged_df[(merged_df['TransactionDt']>=merged_df['StartDt']) &            
                        (merged_df['TransactionDt']<=merged_df['EndDt'])]

# merge on integers
cond_join_int = (transactionDf
                 .conditional_join(
                     offerDf, 
                     ('Itemr', 'Itemr', '=='), 
                     ('TransactionDt', 'StartDt', '>='), 
                     ('TransactionDt', 'EndDt', '<=')
                  )
                 )

# merge on strings
cond_join_str = (transactionDf
                 .conditional_join(
                     offerDf, 
                     ('Item', 'Item', '=='), 
                     ('TransactionDt', 'StartDt', '>='), 
                     ('TransactionDt', 'EndDt', '<=')
                  )
                )

%%timeit
merged_df = pd.merge(offerDf,transactionDf,on='Item')
classic_str = merged_df[(merged_df['TransactionDt']>=merged_df['StartDt']) &
                        (merged_df['TransactionDt']<=merged_df['EndDt'])]
292 ms ± 3.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit
merged_df = pd.merge(offerDf,transactionDf,on='Itemr')
classic_int = merged_df[(merged_df['TransactionDt']>=merged_df['StartDt']) &
                        (merged_df['TransactionDt']<=merged_df['EndDt'])]
253 ms ± 2.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit 
(transactionDf
.conditional_join(
    offerDf, 
    ('Item', 'Item', '=='), 
    ('TransactionDt', 'StartDt', '>='), 
    ('TransactionDt', 'EndDt', '<=')
   )
)
256 ms ± 9.66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit 
(transactionDf
.conditional_join(
    offerDf, 
    ('Itemr', 'Itemr', '=='), 
    ('TransactionDt', 'StartDt', '>='), 
    ('TransactionDt', 'EndDt', '<=')
   )
)
71.8 ms ± 2.24 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# check that both dataframes are equal
cols = ['Item', 'TransactionDt', 'Sales', 'Itemr_y','StartDt', 'EndDt', 'Itemr_x']
cond_join_str = cond_join_str.drop(columns=('right', 'Item')).set_axis(cols, axis=1)

(cond_join_str
.sort_values(cond_join_str.columns.tolist())
.reset_index(drop=True)
.reindex(columns=classic_str.columns)
.equals(
    classic_str
    .sort_values(classic_str.columns.tolist())
    .reset_index(drop=True)
))

True

上一个：基于索引条件对 Pandas 数据帧进行操作

下一个：在 pandas 数据帧中使用 for 循环和 .append 向列表添加值

熊猫合并 101

Pandas Merging 101

目录

评论

说得够多了 - 只是告诉我如何使用！`merge`

设置和基础知识

其他 JOIN - LEFT-Excluding、RIGHT-Excluding 和 FULL-Excluding/ANTI JOIN

键列的不同名称

避免输出中出现重复的键列

仅合并其中一个 `DataFrame` 中的一列

合并多个列

**其他有用的`合并*` 操作和函数**

继续阅读

评论

评论

评论

泛化为多个 DataFrame

唯一键上的多路合并

对具有重复项的键进行多路合并

继续阅读

基于索引的联接

TL;博士

索引到索引联接

列联接的索引

有效使用命名索引 [pandas >= 0.23]

继续阅读

加入 101

内部连接

外部连接或完全连接

右加入

左加入

熊猫合并 101

Pandas Merging 101

目录

评论

说得够多了 - 只是告诉我如何使用！merge

设置和基础知识

其他 JOIN - LEFT-Excluding、RIGHT-Excluding 和 FULL-Excluding/ANTI JOIN

键列的不同名称

避免输出中出现重复的键列

仅合并其中一个 DataFrame 中的一列

合并多个列

其他有用的合并* 操作和函数

继续阅读

评论

评论

评论

泛化为多个 DataFrame

唯一键上的多路合并

对具有重复项的键进行多路合并

继续阅读

基于索引的联接

TL;博士

索引到索引联接

列联接的索引

有效使用命名索引 [pandas >= 0.23]

继续阅读

加入 101

内部连接

外部连接或完全连接

右加入

左加入

说得够多了 - 只是告诉我如何使用！`merge`

仅合并其中一个 `DataFrame` 中的一列

**其他有用的`合并*` 操作和函数**