熊猫.合并#

熊猫。合并( left , right , how = 'inner' , on = None , left_on = None , right_on = None , left_index = False , right_index = False , sort = False , suffixes = ('_x', '_y') , copy =无,指标= False ,验证=无) [来源] #

使用数据库样式连接合并 DataFrame 或命名 Series 对象。

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

连接是在列或索引上完成的。如果在列上连接列，则 DataFrame 索引将被忽略。否则，如果连接索引上的索引或一列或多列上的索引，则索引将被传递。执行交叉合并时，不允许合并任何列规范。

警告

如果两个键列都包含键为空值的行，则这些行将相互匹配。这与通常的 SQL 连接行为不同，可能会导致意外结果。

参数：
左DataFrame 或命名系列
正确的DataFrame 或命名系列

要合并的对象。

如何{'left', 'right', 'outer', 'inner', 'cross'}, 默认'inner'

要执行的合并类型。

  • left：仅使用左框架中的键，类似于 SQL 左外连接；保留按键顺序。

  • right：仅使用右框架中的键，类似于 SQL 右外连接；保留按键顺序。

  • 外部：使用两个框架中的键的并集，类似于 SQL 完全外部连接；按字典顺序对键进行排序。

  • 内部：使用两个帧的键的交集，类似于 SQL 内部联接；保留左键的顺序。

  • cross：从两个帧创建笛卡尔积，保留左键的顺序。

标签或清单上

要连接的列或索引级别名称。这些必须在两个 DataFrame 中找到。如果on为 None 并且不合并索引，则默认为两个 DataFrame 中列的交集。

left_on标签或列表，或类似数组

要连接到左侧 DataFrame 的列或索引级别名称。也可以是左侧 DataFrame 长度的数组或数组列表。这些数组被视为列。

right_on标签或列表，或类似数组

要连接到右侧 DataFrame 中的列或索引级别名称。也可以是正确 DataFrame 长度的数组或数组列表。这些数组被视为列。

left_index bool, 默认 False

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

right_index bool, 默认 False

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

排序bool，默认 False

在结果 DataFrame 中按字典顺序对连接键进行排序。如果为 False，则连接键的顺序取决于连接类型（how 关键字）。

后缀列表，默认为（“_x”，“_y”）

长度为 2 的序列，其中每个元素都可以是一个字符串，指示分别添加到左侧和右侧重叠列名称的后缀 。传递None值而不是字符串，以指示左侧或 右侧的列名称应保持原样，不带后缀。至少其中一个值不得为 None。

复制布尔值，默认 True

如果为 False，请尽可能避免复制。

笔记

copy关键字将改变 pandas 3.0 中的行为 。默认情况下会启用Copy-on-Write ，这意味着所有带有 copy关键字的方法都将使用惰性复制机制来推迟复制并忽略copy关键字。 copy关键字将在 pandas 的未来版本中删除。

您已经可以通过启用写入时复制来获得未来的行为和改进pd.options.mode.copy_on_write = True

指示符bool 或 str，默认 False

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

验证str，可选

如果指定，则检查合并是否属于指定类型。

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

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

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

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

返回：
数据框

两个合并对象的 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

将 DataFrame df1 和 df2 与附加到任何重叠列的指定左后缀和右后缀合并。

>>> 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

合并 DataFrame df1 和 df2，但如果 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