pandas.concat #

熊猫。concat ( objs , * , axis = 0 , join = 'outer' , ignore_index = False , keys = None , levels = None ,名称= None , verify_integrity = False , sort = False , copy = None ) [来源] #

沿特定轴连接 pandas 对象。

允许沿其他轴进行可选设置逻辑。

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

参数：

objs Series 或 DataFrame 对象的序列或映射: 如果传递了映射，则排序后的键将用作键参数，除非传递了映射，在这种情况下将选择值（见下文）。任何 None 对象都将被静默删除，除非它们都是 None，在这种情况下将引发 ValueError。
轴{0/'index', 1/'columns'}，默认 0: 沿其连接的轴。
加入{'inner', 'outer'}, 默认 'outer': 如何处理其他轴（或多个轴）上的索引。
ignore_index bool，默认 False: 如果为 True，则不使用串联轴上的索引值。生成的轴将标记为 0、...、n - 1。如果您要连接对象，而连接轴没有有意义的索引信息，则这非常有用。请注意，连接中仍然遵循其他轴上的索引值。
按键顺序，默认无: 如果通过了多个级别，则应包含元组。使用传递的键作为最外层构建层次索引。
序列的级别列表，默认无: 用于构造多重索引的特定级别（唯一值）。否则，将从密钥中推断出它们。
名称列表，默认无: 生成的分层索引中的级别的名称。
verify_integrity bool, 默认 False: 检查新的串联轴是否包含重复项。相对于实际的数据串联，这可能非常昂贵。
排序bool，默认 False: 如果尚未对齐，则对非串联轴进行排序。一个例外是当非串联轴是 DatetimeIndex 且 join='outer' 并且轴尚未对齐时。在这种情况下，非串联轴始终按字典顺序排序。
复制布尔值，默认 True: 如果为 False，则不要复制不必要的数据。

返回：

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

也可以看看

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

笔记

键、级别和名称参数都是可选的。

可以在此处找到有关此方法如何与其他工具结合使用以组合 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

将具有重叠列的对象组合起来，并仅返回通过传递给关键字参数DataFrame而共享的对象。innerjoin

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

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

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