dask.dataframe.merge

dask.dataframe.merge¶

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

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

连接是在列或索引上完成的。如果是在列上连接列，DataFrame 的索引 将被忽略。否则，如果是在索引上连接索引，或者在列上连接索引，索引将被传递。在进行交叉合并时，不允许指定要合并的列。

警告

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

参数

左DataFrame 或命名 Series

右DataFrame 或命名 Series

要合并的对象。

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

要执行的合并类型。

left: 仅使用左帧中的键，类似于SQL的左外连接；保留键的顺序。
right: 仅使用右帧中的键，类似于SQL的右外连接；保留键的顺序。
outer: 使用两个帧中键的并集，类似于SQL的全外连接；按字典顺序排序键。
inner: 使用两个帧中键的交集，类似于SQL的内部连接；保留左侧键的顺序。
cross: 从两个数据框创建笛卡尔积，保留左侧键的顺序。

开标签或列表

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

left_on标签或列表，或类数组

在左DataFrame中用于连接的列或索引级别名称。也可以是与左DataFrame长度相同的数组或数组列表。这些数组被视为列。

right_on标签或列表，或类数组

在右DataFrame中用于连接的列或索引级别名称。也可以是与右DataFrame长度相同的数组或数组列表。这些数组被视为列。

left_indexbool, 默认 False

使用左侧DataFrame的索引作为连接键。如果是MultiIndex，另一个DataFrame中的键数（无论是索引还是若干列）必须与层级数匹配。

right_indexbool, 默认 False

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

排序bool, 默认 False

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

后缀类似列表，默认值为 (“_x”, “_y”)

一个长度为2的序列，其中每个元素是可选的字符串，分别指示在 left 和 right 中重叠列名后添加的后缀。传递 None 值而不是字符串，以指示应保留 left 或 right 中的列名，不添加后缀。至少一个值不能为 None。

复制bool, 默认 True

如果为 False，尽量避免复制。

备注

copy 关键字将在 pandas 3.0 中改变行为。写时复制将被默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来版本的 pandas 中被移除。

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

指标布尔值或字符串，默认 False

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

验证str, 可选

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

“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

将 df1 和 df2 基于 lkey 和 rkey 列进行合并。值列会附加默认后缀，_x 和 _y。

>>> df1.merge(df2, left_on='lkey', right_on='rkey')
  lkey  value_x rkey  value_y
foo        1  foo        5
foo        1  foo        8
bar        2  bar        6
baz        3  baz        7
foo        5  foo        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，但如果 DataFrames 有任何重叠的列，则引发异常。

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

dask.dataframe.concat

dask.dataframe.merge_asof