pandas.concat#

pandas.concat(objs, *, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=<no_default>)[源代码][源代码]#

沿特定轴连接 pandas 对象。

允许在其他轴上进行可选的集合逻辑。

还可以在连接轴上添加一层层次索引，如果在传递的轴号上标签相同（或重叠），这可能很有用。

参数:

objs一个可迭代对象或 Series 或 DataFrame 对象的映射: 如果传递了一个映射，键将被用作 keys 参数，除非传递了该参数，在这种情况下将选择值（见下文）。任何 None 对象将被静默丢弃，除非它们都是 None，在这种情况下将引发 ValueError。
轴{0/’索引’, 1/’列’}, 默认 0: 要沿其连接的轴。
join{‘inner’, ‘outer’}, 默认 ‘outer’: 如何在其他轴（或轴）上处理索引。
ignore_index布尔值, 默认为 False: 如果为真，则不使用沿连接轴的索引值。结果轴将被标记为0, …, n - 1。如果你连接的对象在连接轴上没有有意义的索引信息，这很有用。请注意，其他轴上的索引值在连接中仍然会被保留。
键序列，默认无: 如果传递了多个级别，应包含元组。使用传递的键作为最外层来构建层次索引。
levels序列列表，默认为无: 用于构建 MultiIndex 的特定级别（唯一值）。否则，它们将从键中推断出来。
名称列表，默认为无: 生成的层次索引中各级别的名称。
verify_integrity布尔值, 默认为 False: 检查新的连接轴是否包含重复项。相对于实际的数据连接，这可能会非常昂贵。
排序布尔值, 默认为 False: 排序非连接轴。一个例外是当非连接轴是一个 DatetimeIndex 并且 join=’outer’ 且该轴尚未对齐时。在这种情况下，非连接轴总是按字典顺序排序。
复制布尔值, 默认为 False: 如果为 False，则不要不必要地复制数据。

备注

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

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

自 3.0.0 版本弃用.

返回:

对象, objs 的类型: 当沿着索引（axis=0）连接所有 Series 时，返回一个 Series。当 objs 包含至少一个 DataFrame 时，返回一个 DataFrame。当沿着列（axis=1）连接时，返回一个 DataFrame。

参见

DataFrame.join: 使用索引连接DataFrame。
DataFrame.merge: 按索引或列合并DataFrame。

备注

keys、levels 和 names 参数都是可选的。

这种方法如何与其他工具结合使用以组合 pandas 对象的演练可以在这里找到。

不推荐通过在 for 循环中添加单行来构建 DataFrame。建议先构建一个行列表，然后通过一次 concat 操作创建 DataFrame。

例子

合并两个 Series。

>>> s1 = pd.Series(["a", "b"])
>>> s2 = pd.Series(["c", "d"])
>>> pd.concat([s1, s2])
0    a
1    b
0    c
1    d
dtype: object

通过将 ignore_index 选项设置为 True，清除现有索引并在结果中重置它。

>>> pd.concat([s1, s2], ignore_index=True)
0    a
1    b
2    c
3    d
dtype: object

使用 keys 选项在最外层的数据中添加一个层次索引。

>>> pd.concat([s1, s2], keys=["s1", "s2"])
s1  0    a
    1    b
s2  0    c
    1    d
dtype: object

使用 names 选项标记您创建的索引键。

>>> pd.concat([s1, s2], keys=["s1", "s2"], names=["Series name", "Row ID"])
Series name  Row ID
s1           0         a
             1         b
s2           0         c
             1         d
dtype: object

合并两个具有相同列的 DataFrame 对象。

>>> df1 = pd.DataFrame([["a", 1], ["b", 2]], columns=["letter", "number"])
>>> df1
  letter  number
0      a       1
1      b       2
>>> df2 = pd.DataFrame([["c", 3], ["d", 4]], columns=["letter", "number"])
>>> df2
  letter  number
0      c       3
1      d       4
>>> pd.concat([df1, df2])
  letter  number
0      a       1
1      b       2
0      c       3
1      d       4

结合具有重叠列的 DataFrame 对象并返回所有内容。交集外的列将用 NaN 值填充。

>>> df3 = pd.DataFrame(
...     [["c", 3, "cat"], ["d", 4, "dog"]], columns=["letter", "number", "animal"]
... )
>>> df3
  letter  number animal
0      c       3    cat
1      d       4    dog
>>> pd.concat([df1, df3], sort=False)
  letter  number animal
0      a       1    NaN
1      b       2    NaN
0      c       3    cat
1      d       4    dog

通过将 inner 传递给 join 关键字参数，组合具有重叠列的 DataFrame 对象，并仅返回那些共享的列。

>>> pd.concat([df1, df3], join="inner")
  letter  number
0      a       1
1      b       2
0      c       3
1      d       4

通过传入 axis=1 将 DataFrame 对象沿 x 轴水平组合。

>>> df4 = pd.DataFrame(
...     [["bird", "polly"], ["monkey", "george"]], columns=["animal", "name"]
... )
>>> pd.concat([df1, df4], axis=1)
  letter  number  animal    name
0      a       1    bird   polly
1      b       2  monkey  george

使用 verify_integrity 选项防止结果包含重复的索引值。

>>> df5 = pd.DataFrame([1], index=["a"])
>>> df5
   0
a  1
>>> df6 = pd.DataFrame([2], index=["a"])
>>> df6
   0
a  2
>>> pd.concat([df5, df6], verify_integrity=True)
Traceback (most recent call last):
    ...
ValueError: Indexes have overlapping values: ['a']

在 DataFrame 对象的末尾追加一行。

>>> df7 = pd.DataFrame({"a": 1, "b": 2}, index=[0])
>>> df7
    a   b
0   1   2
>>> new_row = pd.Series({"a": 3, "b": 4})
>>> new_row
a    3
b    4
dtype: int64
>>> pd.concat([df7, new_row.to_frame().T], ignore_index=True)
    a   b
0   1   2
1   3   4