pandas.concat

pandas.concat(objs, *, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=None)

沿特定轴连接 pandas 对象。

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

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

Parameters:

objsSeries 或 DataFrame 对象的序列或映射

如果传递了映射，则将按排序后的键用作 keys 参数，除非已传递，在这种情况下将选择值（见下文）。任何 None 对象都将被静默删除，除非它们全部为 None，在这种情况下将引发 ValueError。

axis{0/’index’, 1/’columns’}, default 0

连接的轴。

<strong>join</strong>{‘inner’, ‘outer’}, default ‘outer’

如何处理其他轴（或多个轴）上的索引。

ignore_indexbool，默认 False

如果为 True，则不使用沿连接轴的索引值。结果轴将被标记为 0, …, n - 1。如果您连接的对象在连接轴上没有有意义的索引信息，则此选项很有用。注意，其他轴上的索引值在连接中仍然被尊重。

keyssequence, default None

如果传递了多个级别，则应包含元组。使用传递的键作为最外层来构建分层索引。

levelslist of sequences, default None

用于构造 MultiIndex 的特定级别（唯一值）。否则将从键中推断出来。

nameslist, default None

结果分层索引中级别的名称。

verify_integritybool，默认 False

检查新连接的轴是否包含重复项。这可能比实际数据连接的成本高很多。

sortbool，默认 False

如果非连接轴尚未对齐，则对其进行排序。有一个例外：当非连接轴是 DatetimeIndex 且 join=’outer’ 且轴尚未对齐时。在这种情况下，非连接轴始终按字典顺序排序。

copybool, default True

如果为 False，则避免不必要地复制数据。

Returns:

object, type of objs

当沿索引（axis=0）连接所有 Series 时，返回一个 Series。当 objs 包含至少一个 DataFrame 时，返回一个 DataFrame。当沿列（axis=1）连接时，返回一个 DataFrame。

参见

DataFrame.join

使用索引连接 DataFrames。

DataFrame.merge

按索引或列合并 DataFrames。

Notes

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

有关此方法如何与其他合并 pandas 对象的工具结合使用的演练，请参阅 here 。

不建议在 for 循环中通过添加单行来构建 DataFrames。构建行列表并在一次 concat 中创建一个 DataFrame。

Examples

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