pandas.DataFrame.merge#

DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=<no_default>, indicator=False, validate=None)[来源]#

使用数据库风格的连接合并 DataFrame 或命名 Series 对象。

命名 Series 对象被视为具有单个命名列的 DataFrame。

联接是基于列或索引进行的。如果基于列联接列，则 DataFrame 索引将被忽略。否则，如果基于索引联接索引或基于索引联接列，则将传递索引。执行交叉联接时，不允许指定联接的列。

警告

如果两个键列都包含键值为 null 值的行，则这些行将相互匹配。这与常规 SQL JOIN 的行为不同，并且可能导致意外的结果。

参数:
rightDataFrame 或命名 Series

要与之合并的对象。

how{‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’, ‘left_anti’, ‘right_anti’},

默认值 'inner' 要执行的合并类型。

  • left: 仅使用左侧 DataFrame 的键，类似于 SQL 左外连接；保留键的顺序。

  • right: 仅使用右侧 DataFrame 的键，类似于 SQL 右外连接；保留键的顺序。

  • outer: 使用两个 DataFrame 的键的并集，类似于 SQL 全外连接；按字典顺序对键进行排序。

  • inner: 使用两个 DataFrame 的键的交集，类似于 SQL 内连接；保留左键的顺序。

  • cross: 创建两个 DataFrame 的笛卡尔积，保留左键的顺序。

  • left_anti: 仅使用左侧 DataFrame 中不在右侧 DataFrame 中的键，类似于 SQL 左反连接；保留键的顺序。

    已添加到版本 3.0。

  • right_anti: 仅使用右侧 DataFrame 中不在左侧 DataFrame 中的键，类似于 SQL 右反连接；保留键的顺序。

    已添加到版本 3.0。

onHashable 或上述序列

要联接的列或索引级别名称。这些名称必须在两个 DataFrame 中都存在。如果 on 为 None 且不是基于索引联接，则默认为两个 DataFrame 中列的交集。

left_onHashable 或上述序列，或类数组

左侧 DataFrame 中要联接的列或索引级别名称。也可以是长度与左侧 DataFrame 相同的类数组或数组列表。这些类数组被视为列。

right_onHashable 或上述序列，或类数组

右侧 DataFrame 中要联接的列或索引级别名称。也可以是长度与右侧 DataFrame 相同的类数组或数组列表。这些类数组被视为列。

left_indexbool，默认值 False

使用左侧 DataFrame 的索引作为联接键。如果它是 MultiIndex，则另一个 DataFrame 中的键数（索引或多个列）必须与级别数匹配。

right_indexbool，默认值 False

使用右侧 DataFrame 的索引作为联接键。与 left_index 具有相同的注意事项。

sortbool，默认值 False

在结果 DataFrame 中按字典顺序对联接键进行排序。如果为 False，则联接键的顺序取决于联接类型 (how 参数)。

suffixes类列表，默认值为 (“_x”, “_y”)

长度为 2 的序列，其中每个元素都是一个可选的字符串，用于指示添加到 left 和 right 中重叠列名称的后缀。将 None 作为值而不是字符串传递，表示应将来自 left 或 right 的列名称保留原样，不加后缀。至少一个值不能为 None。

copybool，默认值 False

此关键字已被忽略；更改其值将不会影响方法。

已弃用，版本 3.0.0: 此关键字已被忽略，并将在 pandas 4.0 中删除。自 pandas 3.0 起，此方法始终返回一个新对象，并使用延迟复制机制，该机制会推迟复制直到必要时（写时复制）。有关更多详细信息，请参阅关于写时复制的用户指南。

indicatorbool 或 str，默认值 False

如果为 True，则向输出 DataFrame 添加一个名为 “_merge” 的列，其中包含有关每行来源的信息。可以通过提供字符串参数为该列指定不同的名称。该列将具有 Categorical 类型，对于仅出现在左侧 DataFrame 中的合并键的观察值，值为 “left_only”；对于仅出现在右侧 DataFrame 中的合并键的观察值，值为 “right_only”；对于两个 DataFrame 中都找到合并键的观察值，值为 “both”。

validatestr，可选

如果指定，则检查合并是否为指定的类型。

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

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

  • “many_to_one” 或 “m:1”: 检查合并键在右侧数据集是否唯一。

  • “many_to_many” 或 “m:m”: 允许，但不会导致检查。

返回:
DataFrame

两个合并对象的 DataFrame。

另请参阅

merge_ordered

带有可选填充/插值的合并。

merge_asof

按最近的键合并。

DataFrame.join

使用索引的类似方法。

示例

>>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
...                     'value': [1, 2, 3, 5]})
>>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'],
...                     'value': [5, 6, 7, 8]})
>>> df1
    lkey value
0   foo      1
1   bar      2
2   baz      3
3   foo      5
>>> df2
    rkey value
0   foo      5
1   bar      6
2   baz      7
3   foo      8

在 lkey 和 rkey 列上合并 df1 和 df2。值列会附加默认后缀 _x 和 _y。

>>> df1.merge(df2, left_on='lkey', right_on='rkey')
  lkey  value_x rkey  value_y
0  foo        1  foo        5
1  foo        1  foo        8
2  bar        2  bar        6
3  baz        3  baz        7
4  foo        5  foo        5
5  foo        5  foo        8

在 df1 和 df2 上合并 DataFrame，并在任何重叠的列上附加指定的左侧和右侧后缀。

>>> df1.merge(df2, left_on='lkey', right_on='rkey',
...           suffixes=('_left', '_right'))
  lkey  value_left rkey  value_right
0  foo           1  foo            5
1  foo           1  foo            8
2  bar           2  bar            6
3  baz           3  baz            7
4  foo           5  foo            5
5  foo           5  foo            8

在 df1 和 df2 上合并 DataFrame，但如果 DataFrame 具有任何重叠的列，则会引发异常。

>>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False))
Traceback (most recent call last):
...
ValueError: columns overlap but no suffix specified:
    Index(['value'], dtype='object')

>>> df1 = pd.DataFrame({'a': ['foo', 'bar'], 'b': [1, 2]})
>>> df2 = pd.DataFrame({'a': ['foo', 'baz'], 'c': [3, 4]})
>>> df1
      a  b
0   foo  1
1   bar  2
>>> df2
      a  c
0   foo  3
1   baz  4

>>> df1.merge(df2, how='inner', on='a')
      a  b  c
0   foo  1  3

>>> df1.merge(df2, how='left', on='a')
      a  b  c
0   foo  1  3.0
1   bar  2  NaN

>>> df1 = pd.DataFrame({'left': ['foo', 'bar']})
>>> df2 = pd.DataFrame({'right': [7, 8]})
>>> df1
    left
0   foo
1   bar
>>> df2
    right
0   7
1   8

>>> df1.merge(df2, how='cross')
   left  right
0   foo      7
1   foo      8
2   bar      7
3   bar      8
本页内容