pandas.concat#

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

使用沿其他轴的可选设置逻辑沿特定轴连接Pandas对象。

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

参数

objs序列或DataFrame对象的序列或映射: 如果传递映射，则排序的键将用作 keys 参数，除非它被传递，在这种情况下，这些值将被选择(见下文)。任何None对象都将静默丢弃，除非它们都为None，在这种情况下将引发ValueError。
axis{0/‘index’，1/‘Columns’}，默认0: 要连接的轴。
join{‘内部’，‘外部’}，默认为‘外部’: 如何处理其他轴上的索引。
ignore_index布尔值，默认为False: 如果为True，则不使用沿串联轴的索引值。生成的轴将被标记为0，...，n-1。如果要串联的对象的串联轴没有有意义的索引信息，这将非常有用。请注意，连接中仍考虑其他轴上的索引值。
keys序列，默认为无: 如果通过了多个级别，则应包含元组。使用传递的键作为最外层构建分层索引。
levels序列列表，默认为无: 用于构造多索引的特定级别(唯一值)。否则，将从密钥中推断出它们。
names列表，默认为无: 生成的分层索引中的级别的名称。
verify_integrity布尔值，默认为False: 检查新的串联轴是否包含重复项。与实际的数据串联相比，这可能非常昂贵。
sort布尔值，默认为False: 时，如果未对齐非串联轴，则对其进行排序 join 是“外部的”。这在以下情况下不起作用 join='inner' ，它已经保留了非级联轴的顺序。

在 1.0.0 版更改: 默认情况下更改为不排序。
copy布尔值，默认为True: 如果为False，则不要不必要地复制数据。

退货

对象，对象的类型: 在串联所有 Series 沿着索引(轴=0)，一个 Series 被归还了。什么时候 objs 包含至少一个 DataFrame ，a DataFrame 被归还了。沿列(轴=1)串联时， DataFrame 返回。

参见

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

注意事项

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

可以找到此方法如何与其他组合Pandas对象的工具配合使用的演练 here 。

示例

将两个组合 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 对象，并且只返回那些通过传递 inner 发送到 join 关键字参数。

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

pandas.merge_asof

pandas.get_dummies