maxframe.dataframe.concat#

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

沿着特定轴连接 DataFrame 对象，并可选择在其他轴上应用集合逻辑。

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

参数:

objs (a sequence or mapping of Series or DataFrame objects) -- 如果传递了映射，则将使用排序后的键作为 keys 参数，除非已传递该参数，在这种情况下将选择值（见下文）。任何 None 对象将被静默丢弃，除非它们全部为 None，此时将引发 ValueError。
axis ({0/'index', 1/'columns'}, default 0) -- 要连接的轴。
join ({'inner', 'outer'}, default 'outer') -- 如何处理其他轴上的索引。
ignore_index (bool, default False) -- 如果为 True，则不使用连接轴上的索引值。结果轴将被标记为 0, ..., n - 1。如果你连接的对象的连接轴没有有意义的索引信息，则这很有用。请注意，其他轴上的索引值在连接中仍然会被保留。
keys (sequence, default None) -- 如果传递了多个级别，则应包含元组。使用传递的键作为最外层构造分层索引。
levels (list of sequences, default None) -- 用于构造 MultiIndex 的特定级别（唯一值）。否则将从键中推断出来。
names (list, default None) -- 结果分层索引中各级别的名称。
verify_integrity (bool, default False) -- 检查新的连接轴是否包含重复项。相对于实际的数据连接，这可能非常耗时。
sort (bool, default False) -- 如果 join 为 'outer' 且非连接轴尚未对齐，则对其进行排序。当 join='inner' 时无效，因为此时已经保留了非连接轴的顺序。
copy (bool, default True) -- 如果为 False，则不必要时不复制数据。

返回:

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

返回类型:

object, type of objs

参见

Series.append: 连接 Series。
DataFrame.append: 连接 DataFrames。
DataFrame.join: 使用索引连接 DataFrames。
DataFrame.merge: 通过索引或列合并 DataFrames。

备注

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

有关此方法如何与其他组合 pandas 对象的工具配合使用的详细说明，请参见此处。

示例

合并两个 Series。

>>> import maxframe.dataframe as md
>>> s1 = md.Series(['a', 'b'])
>>> s2 = md.Series(['c', 'd'])
>>> md.concat([s1, s2]).execute()
0    a
1    b
0    c
1    d
dtype: object

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

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

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

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

使用 names 选项为创建的索引键添加标签。

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

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

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

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

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

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

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

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

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

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

>>> df5 = md.DataFrame([1], index=['a'])
>>> df5.execute()
   0
a  1
>>> df6 = md.DataFrame([2], index=['a'])
>>> df6.execute()
   0
a  2