pandas.DataFrame.join#

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False, validate=None)[源码]#

连接另一个 DataFrame 的列。

将列与 other DataFrame 连接，可以基于索引或键列。通过传递一个列表，可以高效地一次连接多个 DataFrame 对象。

参数:
otherDataFrame、Series 或包含它们的任意组合的列表

索引应与此 DataFrame 的一个列相似。如果传递了 Series，则必须设置其 name 属性，该属性将用作结果连接 DataFrame 中的列名。

onstr, list of str, 或 array-like, 可选

调用方中的列或索引级别名称，用于连接 other 中的索引，否则连接索引-索引。如果给出多个值，则 other DataFrame 必须有一个 MultiIndex。如果连接键尚未包含在调用 DataFrame 中，则可以传递一个数组作为连接键。类似于 Excel 的 VLOOKUP 操作。

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

默认值为 ‘left’ 如何处理这两个对象的连接操作。

  • left: 使用调用方的 DataFrame 的索引（如果指定了 on，则使用列）。

  • right: 使用 other 的索引。

  • outer: 形成调用方 DataFrame 的索引（如果指定了 on，则使用列）与 other 的索引的并集，并按字典顺序排序。

  • inner: 形成调用方 DataFrame 的索引（如果指定了 on，则使用列）与 other 的索引的交集，保留调用方 DataFrame 的顺序。

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

  • left_anti: 使用调用方 DataFrame 的索引与 other 的索引的集合差集。

  • right_anti: 使用 other 的索引与调用方 DataFrame 的索引的集合差集。

lsuffixstr, 默认 ‘’

用于来自左侧 DataFrame 的重叠列的后缀。

rsuffixstr, 默认 ‘’

用于来自右侧 DataFrame 的重叠列的后缀。

sortbool，默认值 False

按连接键按字典顺序排列结果 DataFrame。如果为 False，连接键的顺序取决于连接类型（how 参数）。

validatestr，可选

如果指定，则检查连接是否为指定的类型。

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

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

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

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

返回:
DataFrame

一个包含来自调用方和 other 的列的 DataFrame。

另请参阅

DataFrame.merge

用于列-列操作。

注意

当传递 DataFrame 对象列表时，不支持 on、lsuffix 和 rsuffix 参数。

示例

>>> df = pd.DataFrame(
...     {
...         "key": ["K0", "K1", "K2", "K3", "K4", "K5"],
...         "A": ["A0", "A1", "A2", "A3", "A4", "A5"],
...     }
... )

>>> df
  key   A
0  K0  A0
1  K1  A1
2  K2  A2
3  K3  A3
4  K4  A4
5  K5  A5

>>> other = pd.DataFrame({"key": ["K0", "K1", "K2"], "B": ["B0", "B1", "B2"]})

>>> other
  key   B
0  K0  B0
1  K1  B1
2  K2  B2

使用它们的索引连接 DataFrame。

>>> df.join(other, lsuffix="_caller", rsuffix="_other")
  key_caller   A key_other    B
0         K0  A0        K0   B0
1         K1  A1        K1   B1
2         K2  A2        K2   B2
3         K3  A3       NaN  NaN
4         K4  A4       NaN  NaN
5         K5  A5       NaN  NaN

如果我们想使用键列进行连接，我们需要将键设置为 df 和 other 的索引。连接后的 DataFrame 将以键作为其索引。

>>> df.set_index("key").join(other.set_index("key"))
      A    B
key
K0   A0   B0
K1   A1   B1
K2   A2   B2
K3   A3  NaN
K4   A4  NaN
K5   A5  NaN

使用键列进行连接的另一种方法是使用 on 参数。DataFrame.join 始终使用 other 的索引，但我们可以使用 df 中的任何列。此方法会在结果中保留原始 DataFrame 的索引。

>>> df.join(other.set_index("key"), on="key")
  key   A    B
0  K0  A0   B0
1  K1  A1   B1
2  K2  A2   B2
3  K3  A3  NaN
4  K4  A4  NaN
5  K5  A5  NaN

使用非唯一键值显示它们是如何匹配的。

>>> df = pd.DataFrame(
...     {
...         "key": ["K0", "K1", "K1", "K3", "K0", "K1"],
...         "A": ["A0", "A1", "A2", "A3", "A4", "A5"],
...     }
... )

>>> df
  key   A
0  K0  A0
1  K1  A1
2  K1  A2
3  K3  A3
4  K0  A4
5  K1  A5

>>> df.join(other.set_index("key"), on="key", validate="m:1")
  key   A    B
0  K0  A0   B0
1  K1  A1   B1
2  K1  A2   B1
3  K3  A3  NaN
4  K0  A4   B0
5  K1  A5   B1
本页内容