Pandas 合并，连接，连接和比较

 

在连接/合并类型操作的情况下，pandas提供了各种功能，可以轻松地将Series或DataFrame与各种用于索引和关系代数功能的集合逻辑组合在一起。

此外，pandas还提供实用程序来比较两个Series或DataFrame并总结它们之间的差异。

拼接对象

该concat()函数（在pandas主命名空间中）在执行沿轴的串联操作的所有繁重工作，同时在其他轴上执行索引（如果有）的可选设置逻辑（联合或交集）。请注意，我之所以说“如果有”，是因为Series只有一个可能的串联轴。

在深入探讨其所有细节及其功能之前concat，这里有一个简单的示例：

In [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])  ...: In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],  ...: 'B': ['B4', 'B5', 'B6', 'B7'],  ...: 'C': ['C4', 'C5', 'C6', 'C7'],  ...: 'D': ['D4', 'D5', 'D6', 'D7']},  ...: index=[4, 5, 6, 7])  ...: In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],  ...: 'B': ['B8', 'B9', 'B10', 'B11'],  ...: 'C': ['C8', 'C9', 'C10', 'C11'],  ...: 'D': ['D8', 'D9', 'D10', 'D11']},  ...: index=[8, 9, 10, 11])  ...: In [4]: frames = [df1, df2, df3] In [5]: result = pd.concat(frames) 

 

与其在ndarrays上的同级函数一样numpy.concatenate，，pandas.concat 获取同类类型对象的列表或字典，并将它们与“对其他轴的操作”的一些可配置处理进行连接：

pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True) 

• objs：Series或DataFrame对象的序列或映射。如果传递了dict，则排序的键将用作keys参数，除非传递了dict ，在这种情况下，将选择值（请参见下文）。除非所有对象都为None，否则所有None对象都将被静默删除，在这种情况下将引发ValueError。

• axis ：{0，1，…}，默认值为0。要沿其连接的轴。

• join：{'inner'，'outer'}，默认为'outer'。如何处理其他轴上的索引。外部为联合，内部为交叉。

• ignore_index：布尔值，默认为False。如果为True，则不要在串联轴上使用索引值。结果轴将标记为0，…，n-1。如果要串联对象时，串联轴没有有意义的索引信息，这将很有用。请注意，联接中仍会考虑其他轴上的索引值。

• keys：序列，默认为无。使用传递的键作为最外层级别来构造层次结构索引。如果通过了多个级别，则应包含元组。

• levels：序列列表，默认为无。用于构造MultiIndex的特定级别（唯一值）。否则，将从按键推断出它们。

• names：列表，默认为无。生成的层次结构索引中的级别的名称。

• verify_integrity：布尔值，默认为False。检查新的串联轴是否包含重复项。相对于实际数据串联而言，这可能非常昂贵。

• copy：布尔值，默认为True。如果为False，则不要不必要地复制数据。

没有一点上下文，这些论点中的许多就没有多大意义。让我们回顾一下上面的例子。假设我们想将特定的键与切碎的DataFrame的每个片段相关联。我们可以使用keys参数来做到这一点 ：

In [6]: result = pd.concat(frames, keys=['x', 'y', 'z']) 

 

如您所见（如果您已经阅读了文档的其余部分），结果对象的索引具有层次结构索引。这意味着我们现在可以通过键选择每个块：

In [7]: result.loc['y'] Out[7]:   A B C D 4 A4 B4 C4 D4 5 A5 B5 C5 D5 6 A6 B6 C6 D6 7 A7 B7 C7 D7 

看到这如何非常有用并不是一件容易的事。有关此功能的更多详细信息，请参见下文。

注意

值得注意的是concat()（并因此 append()）制作了数据的完整副本，并且不断地重用此功能可能会严重影响性能。如果需要对多个数据集使用该操作，请使用列表推导。

frames = [ process_your_file(f) for f in files ] result = pd.concat(frames) 

在其他轴组逻辑

将多个DataFrame粘合在一起时，可以选择如何处理其他轴（而不是串联的轴）。这可以通过以下两种方式完成：

• 把它们全部结合起来join='outer'。这是默认选项，因为它导致零信息丢失。

• 以十字路口为准join='inner'。

这是每种方法的一个示例。一，默认join='outer' 行为：

In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],  ...: 'D': ['D2', 'D3', 'D6', 'D7'],  ...: 'F': ['F2', 'F3', 'F6', 'F7']},  ...: index=[2, 3, 6, 7])  ...: In [9]: result = pd.concat([df1, df4], axis=1, sort=False) 

 

警告

在版本0.23.0中更改。

默认行为join='outer'是对其他轴排序（在这种情况下为列）。在未来版本的熊猫中，默认设置为不排序。我们指定sort=False现在选择加入新行为。

这是同一件事join='inner'：

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

 

最后，假设我们只是想重用原始DataFrame中的确切索引：

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index) 

同样，我们可以在连接之前建立索引：

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1) Out[12]:   A B C D B D F 0 A0 B0 C0 D0 NaN NaN NaN 1 A1 B1 C1 D1 NaN NaN NaN 2 A2 B2 C2 D2 B2 D2 F2 3 A3 B3 C3 D3 B3 D3 F3 

 

使用串联append

一个有用的快捷方式concat()是append() 在实例方法Series和DataFrame。这些方法实际上早于 concat。它们串联在一起axis=0，即索引：

In [13]: result = df1.append(df2) 

 

对于DataFrame，索引必须是不相交的，但列不必是：

In [14]: result = df1.append(df4, sort=False) 

 

append 可能需要多个对象来串联：

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

 

注意

与append()追加到原始列表并返回的方法不同None，append() 这里的方法不会修改 df1并返回带有df2追加内容的副本。

忽略串联轴上的索引

对于DataFrame没有有意义索引的对象，您可能希望追加它们，而忽略它们可能具有重叠索引的事实。为此，请使用ignore_index参数：

In [16]: result = pd.concat([df1, df4], ignore_index=True, sort=False) 

 

这也是有效的参数DataFrame.append()：

In [17]: result = df1.append(df4, ignore_index=True, sort=False) 

 

与混合ndim串联

您可以将Series和混合在一起DataFrame。该 Series会转化为DataFrame与列名的名称Series。

In [18]: s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X') In [19]: result = pd.concat([df1, s1], axis=1) 

 

注意

由于我们将a串联Series到a DataFrame，因此我们可以用达到相同的结果DataFrame.assign()。要串联任意数量的熊猫对象（DataFrame或Series），请使用 concat。

如果未命名Series，则将连续编号。

In [20]: s2 = pd.Series(['_0', '_1', '_2', '_3']) In [21]: result = pd.concat([df1, s2, s2, s2], axis=1) 

 

通过ignore_index=True将删除所有名称引用。

In [22]: result = pd.concat([df1, s1], axis=1, ignore_index=True) 

 

与组键更多串联

该keys参数的一个相当普遍的用法是在DataFrame基于现有的创建新参数时覆盖列名称Series。请注意，默认行为是如何使结果（如果存在）DataFrame 继承父Series名称的。

In [23]: s3 = pd.Series([0, 1, 2, 3], name='foo') In [24]: s4 = pd.Series([0, 1, 2, 3]) In [25]: s5 = pd.Series([0, 1, 4, 5]) In [26]: pd.concat([s3, s4, s5], axis=1) Out[26]:   foo 0 1 0 0 0 0 1 1 1 1 2 2 2 4 3 3 3 5 

通过keys参数，我们可以覆盖现有的列名。

In [27]: pd.concat([s3, s4, s5], axis=1, keys=['red', 'blue', 'yellow']) Out[27]:   red blue yellow 0 0 0 0 1 1 1 1 2 2 2 4 3 3 3 5 

让我们考虑第一个示例的变体：

In [28]: result = pd.concat(frames, keys=['x', 'y', 'z']) 

 

您还可以将dict传递给，concat在这种情况下，dict键将用作keys参数（除非指定了其他键）：

In [29]: pieces = {'x': df1, 'y': df2, 'z': df3} In [30]: result = pd.concat(pieces) 

 

In [31]: result = pd.concat(pieces, keys=['z', 'y']) 

 

创建的MultiIndex具有从传递的键和DataFrame片段的索引构成的级别：

In [32]: result.index.levels Out[32]: FrozenList([['z', 'y'], [4, 5, 6, 7, 8, 9, 10, 11]]) 

如果您希望指定其他级别（有时会这样），则可以使用以下levels参数：

In [33]: result = pd.concat(pieces, keys=['x', 'y', 'z'],  ....: levels=[['z', 'y', 'x', 'w']],  ....: names=['group_key'])  ....: 

 

In [34]: result.index.levels Out[34]: FrozenList([['z', 'y', 'x', 'w'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]) 

这是相当深奥的，但是实际上对于实现GroupBy之类的东西（分类变量的顺序有意义）是必要的。

行追加到数据帧

尽管效率不是特别高（因为必须创建一个新对象），但您可以DataFrame通过向传递一个Series或dict来将单个行附加到上 append，这将DataFrame如上所述返回一个新值。

In [35]: s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D']) In [36]: result = df1.append(s2, ignore_index=True) 

 

您应该使用ignore_index此方法来指示DataFrame放弃其索引。如果希望保留索引，则应构造一个索引适当的DataFrame并附加或连接这些对象。

您还可以传递字典或系列的列表：

In [37]: dicts = [{'A': 1, 'B': 2, 'C': 3, 'X': 4},  ....: {'A': 5, 'B': 6, 'C': 7, 'Y': 8}]  ....: In [38]: result = df1.append(dicts, ignore_index=True, sort=False) 

 

数据库样式的DataFrame或命名的Series加入/合并

pandas具有功能全面的，高性能的内存中连接操作，这在逻辑上与SQL等关系数据库非常相似。与其他开放源代码实现（如base::merge.data.frame R中）相比，这些方法的性能明显更好（在某些情况下要好一个数量级）。这样做的原因是仔细的算法设计和.NET中数据的内部布局DataFrame。

有关某些高级策略，请参见本食谱。

熟悉SQL但对熊猫不熟悉的用户可能会对与SQL的比较感兴趣 。

pandas提供了一个功能，merge()作为DataFrame或命名Series对象之间所有标准数据库联接操作的入口点：

pd.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, validate=None) 

• left：一个DataFrame或命名为Series的对象。

• right：另一个DataFrame或命名为Series的对象。

• on：要加入的列或索引级别名称。必须在左右DataFrame和/或Series对象中找到。如果没有通过，left_index并且 right_index是False在DataFrames和/或系列列的交叉点会被推断为联接键。

• left_on：左侧DataFrame或Series中的列或索引级别用作键。可以是列名称，索引级别名称，也可以是长度等于DataFrame或Series长度的数组。

• right_on：右侧DataFrame或Series中的列或索引级别用作键。可以是列名称，索引级别名称，也可以是长度等于DataFrame或Series长度的数组。

• left_index：如果为True，则使用左侧DataFrame或Series中的索引（行标签）作为其连接键。对于具有MultiIndex（分层结构）的DataFrame或Series，级别数必须与正确的DataFrame或Series中的联接键数匹配。

• right_index：与left_index正确的DataFrame或Series的用法相同

• how：其一'left'，'right'，'outer'，'inner'。默认为inner。有关每种方法的详细说明，请参见下文。

• sort：按字典顺序按连接键对结果DataFrame进行排序。默认为True，设置为False可以在许多情况下显着提高性能。

• suffixes：适用于重叠列的字符串后缀元组。默认为。('_x', '_y')

• copy注意：始终True从传递的DataFrame或命名的Series对象复制数据（默认），即使不需要重新索引也是如此。在很多情况下都无法避免，但是可以提高性能/内存使用率。可以避免复制的情况有些病态，但是仍然提供了此选项。

• indicator：将一列添加到输出DataFrame中_merge ，并在每一行的源上提供信息。_merge是分类类型的，left_only对于其合并键仅出现在'left'DataFrame或Series中right_only的观察值，对于仅其合并键仅出现在'right'DataFrame或Series中both的观察值以及在两个视图中均找到观察值的合并键，则取值为。

• validate：字符串，默认为无。如果指定，则检查合并是否为指定的类型。

  • “ one_to_one”或“ 1：1”：检查合并键在左右数据集中是否唯一。

  • “ one_to_many”或“ 1：m”：检查合并键在左数据集中是否唯一。

  • “ many_to_one”或“ m：1”：检查合并键在正确的数据集中是否唯一。

  • “ many_to_many”或“ m：m”：允许，但不进行检查。

注意

用于指定索引水平支撑on，left_on以及 right_on在0.23.0版加入参数。Series在版本0.24.0中添加了对合并命名对象的支持。

返回类型将与相同left。如果left是DataFrame或的名称，Series 并且right是的子类DataFrame，则返回类型仍为DataFrame。

merge是pandas命名空间中的一个函数，它也可以作为 DataFrame实例方法merge()使用，调用 DataFrame被隐式视为联接中的左侧对象。

相关join()方法在merge内部用于索引索引连接（默认情况下）和索引列连接。如果仅在索引上加入，则可能希望使用DataFrame.join来节省一些输入。

合并方法简要入门（关系代数）

诸如SQL之类的关系数据库的经验丰富的用户将熟悉用于描述两个类似于SQL表的结构（DataFrame对象）之间的联接操作的术语。需要考虑的几种情况非常重要：

• 一对一联接：例如，在两个DataFrame对象的索引上联接时（必须包含唯一值）。

• 多对一联接：例如，将索引（唯一）联接到different中的一个或多个列时DataFrame。

• 多对多联接：在列上联接列。

注意

在列上连接列时（可能是多对多连接），传递的DataFrame对象上的任何索引都将被丢弃。

值得花一些时间来理解多对多 连接案例的结果。在SQL /标准关系代数中，如果两个表中的键组合都出现多次，则结果表将具有关联数据的笛卡尔积。这是一个具有一个唯一键组合的非常基本的示例：

In [39]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],  ....: 'A': ['A0', 'A1', 'A2', 'A3'],  ....: 'B': ['B0', 'B1', 'B2', 'B3']})  ....: In [40]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],  ....: 'C': ['C0', 'C1', 'C2', 'C3'],  ....: 'D': ['D0', 'D1', 'D2', 'D3']})  ....: In [41]: result = pd.merge(left, right, on='key') 

 

这是带有多个联接键的更复杂的示例。由于默认情况下，只有出现left和出现的关键right点（相交） how='inner'。

In [42]: left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],  ....: 'key2': ['K0', 'K1', 'K0', 'K1'],  ....: 'A': ['A0', 'A1', 'A2', 'A3'],  ....: 'B': ['B0', 'B1', 'B2', 'B3']})  ....: In [43]: right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],  ....: 'key2': ['K0', 'K0', 'K0', 'K0'],  ....: 'C': ['C0', 'C1', 'C2', 'C3'],  ....: 'D': ['D0', 'D1', 'D2', 'D3']})  ....: In [44]: result = pd.merge(left, right, on=['key1', 'key2']) 

 

的how到参数merge指定如何确定哪些键要被包括在所得到的表。如果左表或右表中都没有按键组合，则联接表中的值将为 NA。以下是how选项及其SQL等效名称的摘要：

合并方式	SQL连接名称	描述
left	LEFT OUTER JOIN	仅使用左框中的关键点
right	RIGHT OUTER JOIN	仅从右框使用按键
outer	FULL OUTER JOIN	使用两个框架中的键并集
inner	INNER JOIN	使用两个帧的关键点交集

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

 

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

 

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

 

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

 

如果MultiIndex的名称与DataFrame中的列相对应，则可以合并多索引的Series和DataFrame。Series.reset_index()合并之前，使用系列将Series转换为DataFrame ，如以下示例所示。

In [49]: df = pd.DataFrame({"Let": ["A", "B", "C"], "Num": [1, 2, 3]}) In [50]: df Out[50]:   Let Num 0 A 1 1 B 2 2 C 3 In [51]: ser = pd.Series(  ....: ["a", "b", "c", "d", "e", "f"],  ....: index=pd.MultiIndex.from_arrays(  ....: [["A", "B", "C"] * 2, [1, 2, 3, 4, 5, 6]], names=["Let", "Num"]  ....: ),  ....: )  ....: In [52]: ser Out[52]:  Let Num A 1 a B 2 b C 3 c A 4 d B 5 e C 6 f dtype: object In [53]: pd.merge(df, ser.reset_index(), on=['Let', 'Num']) Out[53]:   Let Num 0 0 A 1 a 1 B 2 b 2 C 3 c 

这是另一个在DataFrames中具有重复联接键的示例：

In [54]: left = pd.DataFrame({'A': [1, 2], 'B': [2, 2]}) In [55]: right = pd.DataFrame({'A': [4, 5, 6], 'B': [2, 2, 2]}) In [56]: result = pd.merge(left, right, on='B', how='outer') 

 

警告

在重复键上进行联接/合并会导致返回的帧是行尺寸的乘积，这可能导致内存溢出。在加入大型DataFrame之前，用户有责任管理键中的重复值。

检查重复键

用户可以使用该validate参数自动检查其合并键中是否有意外的重复项。在合并操作之前检查键的唯一性，因此应防止内存溢出。检查密钥唯一性也是确保用户数据结构符合预期的好方法。

在以下示例中，Bright中 存在重复的值DataFrame。由于这不是validate参数中指定的一对一合并，因此 将引发异常。

In [57]: left = pd.DataFrame({'A' : [1,2], 'B' : [1, 2]}) In [58]: right = pd.DataFrame({'A' : [4,5,6], 'B': [2, 2, 2]}) 

In [53]: result = pd.merge(left, right, on='B', how='outer', validate="one_to_one") ... MergeError: Merge keys are not unique in right dataset; not a one-to-one merge 

如果用户知道右边的重复项，DataFrame但要确保左边的DataFrame中没有重复项，则可以改用该 validate='one_to_many'参数，这不会引发异常。

In [59]: pd.merge(left, right, on='B', how='outer', validate="one_to_many") Out[59]:   A_x B A_y 0 1 1 NaN 1 2 2 4.0 2 2 2 5.0 3 2 2 6.0 

该合并指标

merge()接受论点indicator。如果为True，_merge则将将一个名为Categorical-type的列添加到采用值的输出对象：

观察原点	_merge 值
仅在'left'框架中合并关键点	left_only
仅在'right'框架中合并关键点	right_only
在两个框架中合并关键点	both

In [60]: df1 = pd.DataFrame({'col1': [0, 1], 'col_left': ['a', 'b']}) In [61]: df2 = pd.DataFrame({'col1': [1, 2, 2], 'col_right': [2, 2, 2]}) In [62]: pd.merge(df1, df2, on='col1', how='outer', indicator=True) Out[62]:   col1 col_left col_right _merge 0 0 a NaN left_only 1 1 b 2.0 both 2 2 NaN 2.0 right_only 3 2 NaN 2.0 right_only 

该indicator参数还将接受字符串参数，在这种情况下，指标函数将使用传递的字符串的值作为指标列的名称。

In [63]: pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column') Out[63]:   col1 col_left col_right indicator_column 0 0 a NaN left_only 1 1 b 2.0 both 2 2 NaN 2.0 right_only 3 2 NaN 2.0 right_only 

合并dtypes 

合并将保留联接键的dtype。

In [64]: left = pd.DataFrame({'key': [1], 'v1': [10]}) In [65]: left Out[65]:   key v1 0 1 10 In [66]: right = pd.DataFrame({'key': [1, 2], 'v1': [20, 30]}) In [67]: right Out[67]:   key v1 0 1 20 1 2 30 

我们能够保留联接键：

In [68]: pd.merge(left, right, how='outer') Out[68]:   key v1 0 1 10 1 1 20 2 2 30 In [69]: pd.merge(left, right, how='outer').dtypes Out[69]:  key int64 v1 int64 dtype: object 

当然，如果您缺少引入的值，那么生成的dtype将被转换。

In [70]: pd.merge(left, right, how='outer', on='key') Out[70]:   key v1_x v1_y 0 1 10.0 20 1 2 NaN 30 In [71]: pd.merge(left, right, how='outer', on='key').dtypes Out[71]:  key int64 v1_x float64 v1_y int64 dtype: object 

合并将保留category人种的dtypes。另请参阅“类别”部分。

左框架。

In [72]: from pandas.api.types import CategoricalDtype In [73]: X = pd.Series(np.random.choice(['foo', 'bar'], size=(10,))) In [74]: X = X.astype(CategoricalDtype(categories=['foo', 'bar'])) In [75]: left = pd.DataFrame({'X': X,  ....: 'Y': np.random.choice(['one', 'two', 'three'],  ....: size=(10,))})  ....: In [76]: left Out[76]:   X Y 0 bar one 1 foo one 2 foo three 3 bar three 4 foo one 5 bar one 6 bar three 7 bar three 8 bar three 9 foo three In [77]: left.dtypes Out[77]:  X category Y object dtype: object 

正确的框架。

In [78]: right = pd.DataFrame({'X': pd.Series(['foo', 'bar'],  ....: dtype=CategoricalDtype(['foo', 'bar'])),  ....: 'Z': [1, 2]})  ....: In [79]: right Out[79]:   X Z 0 foo 1 1 bar 2 In [80]: right.dtypes Out[80]:  X category Z int64 dtype: object 

合并结果：

In [81]: result = pd.merge(left, right, how='outer') In [82]: result Out[82]:   X Y Z 0 bar one 2 1 bar three 2 2 bar one 2 3 bar three 2 4 bar three 2 5 bar three 2 6 foo one 1 7 foo three 1 8 foo one 1 9 foo three 1 In [83]: result.dtypes Out[83]:  X category Y object Z int64 dtype: object 

注意

类别dtype必须完全相同，这意味着相同的类别和有序属性。否则结果将强制为类别的dtype。

注意

与categorydtype合并相比，在相同的dtype上合并可能会表现出色object。

加入索引

DataFrame.join()是一种将两个可能具有不同索引的列DataFrames合并为单个结果 的便捷方法DataFrame。这是一个非常基本的示例：

In [84]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],  ....: 'B': ['B0', 'B1', 'B2']},  ....: index=['K0', 'K1', 'K2'])  ....: In [85]: right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],  ....: 'D': ['D0', 'D2', 'D3']},  ....: index=['K0', 'K2', 'K3'])  ....: In [86]: result = left.join(right) 

 

In [87]: result = left.join(right, how='outer') 

 

与上述相同，但带有how='inner'。

In [88]: result = left.join(right, how='inner') 

 

此处的数据对齐在索引（行标签）上。使用merge指示其使用索引的附加参数可以实现相同的行为：

In [89]: result = pd.merge(left, right, left_index=True, right_index=True, how='outer') 

 

In [90]: result = pd.merge(left, right, left_index=True, right_index=True, how='inner'); 

 

在索引上关键列

join()接受一个可选on参数，该参数可以是一列或多个列名，它指定传递的DataFrame内容将与中的该列对齐DataFrame。这两个函数调用是完全等效的：

left.join(right, on=key_or_keys) pd.merge(left, right, left_on=key_or_keys, right_index=True, how='left', sort=False) 

显然，您可以选择任何一种更方便的形式。对于多对一连接（其中的一个DataFrame已通过连接键索引），使用join可能会更方便。这是一个简单的示例：

In [91]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],  ....: 'B': ['B0', 'B1', 'B2', 'B3'],  ....: 'key': ['K0', 'K1', 'K0', 'K1']})  ....: In [92]: right = pd.DataFrame({'C': ['C0', 'C1'],  ....: 'D': ['D0', 'D1']},  ....: index=['K0', 'K1'])  ....: In [93]: result = left.join(right, on='key') 

 

In [94]: result = pd.merge(left, right, left_on='key', right_index=True,  ....: how='left', sort=False);  ....: 

 

要加入多个键，传递的DataFrame必须具有MultiIndex：

In [95]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],  ....: 'B': ['B0', 'B1', 'B2', 'B3'],  ....: 'key1': ['K0', 'K0', 'K1', 'K2'],  ....: 'key2': ['K0', 'K1', 'K0', 'K1']})  ....: In [96]: index = pd.MultiIndex.from_tuples([('K0', 'K0'), ('K1', 'K0'),  ....: ('K2', 'K0'), ('K2', 'K1')])  ....: In [97]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],  ....: 'D': ['D0', 'D1', 'D2', 'D3']},  ....: index=index)  ....: 

现在，可以通过传递两个关键列名称来进行连接：

In [98]: result = left.join(right, on=['key1', 'key2']) 

 

默认的DataFrame.join是执行左联接（对于Excel用户，本质上是“ VLOOKUP”操作），该联接仅使用在调用DataFrame中找到的键。其他联接类型（例如内部联接）也可以轻松执行：

In [99]: result = left.join(right, on=['key1', 'key2'], how='inner') 

 

如您所见，这将删除所有不匹配的行。

加入单一指数为多指标

您可以将一个索引DataFrame与一个MultiIndexed级别连接DataFrame。级别将在单索引帧的索引名称与MultiIndexed帧的级别名称上匹配。

In [100]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],  .....: 'B': ['B0', 'B1', 'B2']},  .....: index=pd.Index(['K0', 'K1', 'K2'], name='key'))  .....: In [101]: index = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),  .....: ('K2', 'Y2'), ('K2', 'Y3')],  .....: names=['key', 'Y'])  .....: In [102]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],  .....: 'D': ['D0', 'D1', 'D2', 'D3']},  .....: index=index)  .....: In [103]: result = left.join(right, how='inner') 

 

这是等效的，但是比它更冗长，存储效率更高/更快。

In [104]: result = pd.merge(left.reset_index(), right.reset_index(),  .....: on=['key'], how='inner').set_index(['key','Y'])  .....: 

 

有两个MultiIndexes加入

只要在连接中完全使用了右参数的索引，并且该参数是左参数中索引的子集，就可以用有限的方式来支持它，如下例所示：

In [105]: leftindex = pd.MultiIndex.from_product([list('abc'), list('xy'), [1, 2]],  .....: names=['abc', 'xy', 'num'])  .....: In [106]: left = pd.DataFrame({'v1': range(12)}, index=leftindex) In [107]: left Out[107]:   v1 abc xy num a x 1 0  2 1  y 1 2  2 3 b x 1 4  2 5  y 1 6  2 7 c x 1 8  2 9  y 1 10  2 11 In [108]: rightindex = pd.MultiIndex.from_product([list('abc'), list('xy')],  .....: names=['abc', 'xy'])  .....: In [109]: right = pd.DataFrame({'v2': [100 * i for i in range(1, 7)]}, index=rightindex) In [110]: right Out[110]:   v2 abc xy a x 100  y 200 b x 300  y 400 c x 500  y 600 In [111]: left.join(right, on=['abc', 'xy'], how='inner') Out[111]:   v1 v2 abc xy num a x 1 0 100  2 1 100  y 1 2 200  2 3 200 b x 1 4 300  2 5 300  y 1 6 400  2 7 400 c x 1 8 500  2 9 500  y 1 10 600  2 11 600 

如果不满足该条件，则可以使用以下代码完成具有两个多索引的联接。

In [112]: leftindex = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),  .....: ('K1', 'X2')],  .....: names=['key', 'X'])  .....: In [113]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],  .....: 'B': ['B0', 'B1', 'B2']},  .....: index=leftindex)  .....: In [114]: rightindex = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),  .....: ('K2', 'Y2'), ('K2', 'Y3')],  .....: names=['key', 'Y'])  .....: In [115]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],  .....: 'D': ['D0', 'D1', 'D2', 'D3']},  .....: index=rightindex)  .....: In [116]: result = pd.merge(left.reset_index(), right.reset_index(),  .....: on=['key'], how='inner').set_index(['key', 'X', 'Y'])  .....: 

 

合并列和索引级别的组合

0.23版中的新功能。

字符串作为传递on，left_on和right_on参数可以指列名或索引级别名称。这样就可以DataFrame在索引级别和列的组合上合并 实例，而无需重置索引。

In [117]: left_index = pd.Index(['K0', 'K0', 'K1', 'K2'], name='key1') In [118]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],  .....: 'B': ['B0', 'B1', 'B2', 'B3'],  .....: 'key2': ['K0', 'K1', 'K0', 'K1']},  .....: index=left_index)  .....: In [119]: right_index = pd.Index(['K0', 'K1', 'K2', 'K2'], name='key1') In [120]: right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],  .....: 'D': ['D0', 'D1', 'D2', 'D3'],  .....: 'key2': ['K0', 'K0', 'K0', 'K1']},  .....: index=right_index)  .....: In [121]: result = left.merge(right, on=['key1', 'key2']) 

 

注意

当将DataFrame合并到与两个框架中的索引级别都匹配的字符串上时，索引级别将保留为结果DataFrame中的索引级别。

注意

当仅使用MultiIndex的某些级别合并DataFrame时，多余的级别将从结果合并中删除。为了保留这些级别，请reset_index在执行合并之前将这些级别名称用于将这些级别移动到列。

注意

如果字符串与列名和索引级名称都匹配，则会发出警告，并且列优先。这将在将来的版本中导致歧义错误。

值列重叠

mergesuffixes参数将字符串列表的元组附加到输入DataFrames中重叠的列名称上，以消除结果列的歧义：

In [122]: left = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'v': [1, 2, 3]}) In [123]: right = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'v': [4, 5, 6]}) In [124]: result = pd.merge(left, right, on='k') 

 

In [125]: result = pd.merge(left, right, on='k', suffixes=('_l', '_r')) 

 

DataFrame.join()具有lsuffix和rsuffix行为相似的参数。

In [126]: left = left.set_index('k') In [127]: right = right.set_index('k') In [128]: result = left.join(right, lsuffix='_l', rsuffix='_r') 

 

连接多个DataFrames 

DataFrames也可以传递一个列表或元组以join() 将它们连接到它们的索引上。

In [129]: right2 = pd.DataFrame({'v': [7, 8, 9]}, index=['K1', 'K1', 'K2']) In [130]: result = left.join([right, right2]) 

 

将Series或DataFrame列中的值合并在一起

另一个相当常见的情况是有两个像索引（或类似索引）Series或DataFrame对象和从值想“补丁”值在一个对象匹配的其他指数。这是一个例子：

In [131]: df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],  .....: [np.nan, 7., np.nan]])  .....: In [132]: df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],  .....: index=[1, 2])  .....: 

为此，请使用以下combine_first()方法：

In [133]: result = df1.combine_first(df2) 

 

请注意，DataFrame如果左侧缺少这些值，则此方法仅采用右侧的值DataFrame。相关方法update()更改了非NA值：

In [134]: df1.update(df2) 

 

时间序列友好合并

合并排序的数据

一个merge_ordered()功能允许组合时间序列和其他有序数据。特别是，它具有一个可选fill_method关键字来填充/内插丢失的数据：

In [135]: left = pd.DataFrame({'k': ['K0', 'K1', 'K1', 'K2'],  .....: 'lv': [1, 2, 3, 4],  .....: 's': ['a', 'b', 'c', 'd']})  .....: In [136]: right = pd.DataFrame({'k': ['K1', 'K2', 'K4'],  .....: 'rv': [1, 2, 3]})  .....: In [137]: pd.merge_ordered(left, right, fill_method='ffill', left_by='s') Out[137]:   k lv s rv 0 K0 1.0 a NaN 1 K1 1.0 a 1.0 2 K2 1.0 a 2.0 3 K4 1.0 a 3.0 4 K1 2.0 b 1.0 5 K2 2.0 b 2.0 6 K4 2.0 b 3.0 7 K1 3.0 c 1.0 8 K2 3.0 c 2.0 9 K4 3.0 c 3.0 10 K1 NaN d 1.0 11 K2 4.0 d 2.0 12 K4 4.0 d 3.0 

合并ASOF 

Amerge_asof()与有序左联接相似，不同之处在于我们在最接近的键而不是相等的键上进行匹配。对于中的每一行left DataFrame，我们选择right DataFrame其on键小于左键的最后一行。两个DataFrame都必须按键排序。

可选地，asof合并可以执行逐组合并。by除了键上最接近的匹配之外，此 键均等地匹配on键。

例如; 我们可能有trades，quotes我们想asof 将它们合并。

In [138]: trades = pd.DataFrame({  .....: 'time': pd.to_datetime(['20160525 13:30:00.023',  .....: '20160525 13:30:00.038',  .....: '20160525 13:30:00.048',  .....: '20160525 13:30:00.048',  .....: '20160525 13:30:00.048']),  .....: 'ticker': ['MSFT', 'MSFT',  .....: 'GOOG', 'GOOG', 'AAPL'],  .....: 'price': [51.95, 51.95,  .....: 720.77, 720.92, 98.00],  .....: 'quantity': [75, 155,  .....: 100, 100, 100]},  .....: columns=['time', 'ticker', 'price', 'quantity'])  .....: In [139]: quotes = pd.DataFrame({  .....: 'time': pd.to_datetime(['20160525 13:30:00.023',  .....: '20160525 13:30:00.023',  .....: '20160525 13:30:00.030',  .....: '20160525 13:30:00.041',  .....: '20160525 13:30:00.048',  .....: '20160525 13:30:00.049',  .....: '20160525 13:30:00.072',  .....: '20160525 13:30:00.075']),  .....: 'ticker': ['GOOG', 'MSFT', 'MSFT',  .....: 'MSFT', 'GOOG', 'AAPL', 'GOOG',  .....: 'MSFT'],  .....: 'bid': [720.50, 51.95, 51.97, 51.99,  .....: 720.50, 97.99, 720.50, 52.01],  .....: 'ask': [720.93, 51.96, 51.98, 52.00,  .....: 720.93, 98.01, 720.88, 52.03]},  .....: columns=['time', 'ticker', 'bid', 'ask'])  .....: 

In [140]: trades Out[140]:   time ticker price quantity 0 2016-05-25 13:30:00.023 MSFT 51.95 75 1 2016-05-25 13:30:00.038 MSFT 51.95 155 2 2016-05-25 13:30:00.048 GOOG 720.77 100 3 2016-05-25 13:30:00.048 GOOG 720.92 100 4 2016-05-25 13:30:00.048 AAPL 98.00 100 In [141]: quotes Out[141]:   time ticker bid ask 0 2016-05-25 13:30:00.023 GOOG 720.50 720.93 1 2016-05-25 13:30:00.023 MSFT 51.95 51.96 2 2016-05-25 13:30:00.030 MSFT 51.97 51.98 3 2016-05-25 13:30:00.041 MSFT 51.99 52.00 4 2016-05-25 13:30:00.048 GOOG 720.50 720.93 5 2016-05-25 13:30:00.049 AAPL 97.99 98.01 6 2016-05-25 13:30:00.072 GOOG 720.50 720.88 7 2016-05-25 13:30:00.075 MSFT 52.01 52.03 

默认情况下，我们采用引号的形式。

In [142]: pd.merge_asof(trades, quotes,  .....: on='time',  .....: by='ticker')  .....: Out[142]:   time ticker price quantity bid ask 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN 

我们只在2ms报价时间和交易时间之间进行交易。

In [143]: pd.merge_asof(trades, quotes,  .....: on='time',  .....: by='ticker',  .....: tolerance=pd.Timedelta('2ms'))  .....: Out[143]:   time ticker price quantity bid ask 0 2016-05-25 13:30:00.023 MSFT 51.95 75 51.95 51.96 1 2016-05-25 13:30:00.038 MSFT 51.95 155 NaN NaN 2 2016-05-25 13:30:00.048 GOOG 720.77 100 720.50 720.93 3 2016-05-25 13:30:00.048 GOOG 720.92 100 720.50 720.93 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN 

我们仅在10ms报价时间和交易时间之间进行结算，并且不包括准时匹配。请注意，尽管我们排除了（引号）的完全匹配项，但先前的引号确实会传播到该时间点。

In [144]: pd.merge_asof(trades, quotes,  .....: on='time',  .....: by='ticker',  .....: tolerance=pd.Timedelta('10ms'),  .....: allow_exact_matches=False)  .....: Out[144]:   time ticker price quantity bid ask 0 2016-05-25 13:30:00.023 MSFT 51.95 75 NaN NaN 1 2016-05-25 13:30:00.038 MSFT 51.95 155 51.97 51.98 2 2016-05-25 13:30:00.048 GOOG 720.77 100 NaN NaN 3 2016-05-25 13:30:00.048 GOOG 720.92 100 NaN NaN 4 2016-05-25 13:30:00.048 AAPL 98.00 100 NaN NaN 

比较对象

使用compare()和compare()方法，您可以分别比较两个DataFrame或Series，并总结它们之间的差异。

V1.1.0中添加了此功能。

例如，您可能想要比较两个DataFrame并并排堆叠它们的差异。

In [145]: df = pd.DataFrame(  .....: {  .....: "col1": ["a", "a", "b", "b", "a"],  .....: "col2": [1.0, 2.0, 3.0, np.nan, 5.0],  .....: "col3": [1.0, 2.0, 3.0, 4.0, 5.0]  .....: },  .....: columns=["col1", "col2", "col3"],  .....: )  .....: In [146]: df Out[146]:   col1 col2 col3 0 a 1.0 1.0 1 a 2.0 2.0 2 b 3.0 3.0 3 b NaN 4.0 4 a 5.0 5.0 

In [147]: df2 = df.copy() In [148]: df2.loc[0, 'col1'] = 'c' In [149]: df2.loc[2, 'col3'] = 4.0 In [150]: df2 Out[150]:   col1 col2 col3 0 c 1.0 1.0 1 a 2.0 2.0 2 b 3.0 4.0 3 b NaN 4.0 4 a 5.0 5.0 

In [151]: df.compare(df2) Out[151]:   col1 col3  self other self other 0 a c NaN NaN 2 NaN NaN 3.0 4.0 

默认情况下，如果两个对应的值相等，它们将显示为NaN。此外，如果整个行/列中的所有值都将从结果中省略。其余差异将在列上对齐。

如果需要，可以选择将差异堆叠在行上。

In [152]: df.compare(df2, align_axis=0) Out[152]:   col1 col3 0 self a NaN  other c NaN 2 self NaN 3.0  other NaN 4.0 

如果您希望保留所有原始行和列，请将keep_shape参数设置为True。

In [153]: df.compare(df2, keep_shape=True) Out[153]:   col1 col2 col3  self other self other self other 0 a c NaN NaN NaN NaN 1 NaN NaN NaN NaN NaN NaN 2 NaN NaN NaN NaN 3.0 4.0 3 NaN NaN NaN NaN NaN NaN 4 NaN NaN NaN NaN NaN NaN 

您也可以保留所有原始值，即使它们相等。