Python 数据处理 —— pandas 合并连接之 concat

前言

pandas 提供了各种工具，可以轻松地将不同的 Series 或 DataFrame 连接、合并在一起

此外，pandas 还提供了比较两个 Series 或 DataFrame 对象差异的实用工具

连接对象

concat() 函数能够沿指定轴执行连接操作，同时对其他轴上的索引(如果有的话，Series 只有一个轴)执行可选的集合运算(并集或交集)

下面是一个简单的示例

In [1]: df1 = pd.DataFrame(
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: )
   ...: 

In [2]: df2 = pd.DataFrame(
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: )
   ...: 

In [3]: df3 = pd.DataFrame(
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: )
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat(frames)

就像 ndarrays 上的函数 numpy.concatenate 一样，pandas.concat 接收一个相同类型的对象列表或字典，并通过一些配置来设置处理方式并将它们连接起来

pd.concat(
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
)

让我们再来看看上面的例子。假设我们想将特定的键与被切割的 DataFrame 的每一个片段关联起来。我们可以使用 keys 参数来实现。

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

从图中可以看出，在结果对象的索引的最外层添加了相应的索引（变为层次索引）。这意味着我们现在可以按键选择每个块

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

下面将详细介绍此功能

注意：

concat()、append() 都会对数据进行完整的复制，不断重复使用这个函数会造成显著的性能下降。

如果你想在多个数据集上执行该操作，可以使用列表推导式。

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)

同时，当在指定轴上连接 DataFrames 时，pandas 将尽可能尝试保留这些索引或列名。

1 在其他轴上的设置逻辑

当将多个 DataFrame 连接在一起时，您可以通过以下两种方式来选择如何处理其他轴上的数据（即除被连接的轴外）。

• 并集 join='outer'，这是默认选项，因为它不会丢失信息
• 交集 join='inner'

下面是这些方法的一个示例。首先，对于默认的 join='outer'

In [8]: df4 = pd.DataFrame(
   ...:     {
   ...:         "B": ["B2", "B3", "B6", "B7"],
   ...:         "D": ["D2", "D3", "D6", "D7"],
   ...:         "F": ["F2", "F3", "F6", "F7"],
   ...:     },
   ...:     index=[2, 3, 6, 7],
   ...: )
   ...: 

In [9]: result = pd.concat([df1, df4], axis=1)

对于 join='inner' 也是一样的

In [10]: result = pd.concat([df1, df4], axis=1, join="inner")

最后，假设我们只是想重用原始 DataFrame 中的确切索引

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

类似地，我们可以在连接之前进行索引

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

2 使用 append 连接

Series 和 DataFrame 上的 append() 实例方法是 concat() 的一个简单的快捷方式。

该方法实际上早于 concat。它沿着 axis=0 即索引方向进行连接

In [13]: result = df1.append(df2)

在 DataFrame 中，索引必须是不相交的，但列不需要

In [14]: result = df1.append(df4, sort=False)

append 可以接受多个对象来进行连接

In [15]: result = df1.append([df2, df3])

注意：

这里的 append() 方法不同于 list，该方法不会修改 df1 的值，同时返回是添加 df2 后的拷贝

3 忽略连接轴上的索引

对于某些 DataFrame 对象，其上的索引并没有任何意义，同时你可能希望在连接的时候，忽略这些对象的索引可能存在重叠的情况。

要做到这一点，可以使用 ignore_index 参数

In [16]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

这也是 DataFrame.append() 的一个有效参数

In [17]: result = df1.append(df4, ignore_index=True, sort=False)

4 不同维度数据的连接

您也可以将 Series 和 DataFrame 对象连接起来。Series 将被转换为 DataFrame，列名为 Series 的名称

In [18]: s1 = pd.Series(["X0", "X1", "X2", "X3"], name="X")

In [19]: result = pd.concat([df1, s1], axis=1)

对于未命名的 Series，对应的列名将是连续增长的数字

In [20]: s2 = pd.Series(["_0", "_1", "_2", "_3"])

In [21]: result = pd.concat([df1, s2, s2, s2], axis=1)

传递 ignore_index=True 将删除所有名称引用

In [22]: result = pd.concat([df1, s1], axis=1, ignore_index=True)

5 使用 keys 连接

keys 参数的一个常见的用法是，基于现有 Series 创建新 DataFrame 时覆盖列名

默认的行为是如果 Series 的名称存在的话，让生成的 DataFrame 继承

In [23]: s3 = pd.Series([0, 1, 2, 3], name="foo")

In [24]: s4 = pd.Series([0, 1, 2, 3])

In [25]: s5 = pd.Series([0, 1, 4, 5])

In [26]: pd.concat([s3, s4, s5], axis=1)
Out[26]: 
   foo  0  1
0    0  0  0
1    1  1  1
2    2  2  4
3    3  3  5

通过 keys 参数，我们可以覆盖现有的列名

In [27]: pd.concat([s3, s4, s5], axis=1, keys=["red", "blue", "yellow"])
Out[27]: 
   red  blue  yellow
0    0     0       0
1    1     1       1
2    2     2       4
3    3     3       5

让我们考虑第一个例子的一个变体

In [28]: result = pd.concat(frames, keys=["x", "y", "z"])

你也可以在 concat 中传递一个字典，在这种情况下，字典的键将用于 keys 参数(除非指定了其他键)

In [29]: pieces = {"x": df1, "y": df2, "z": df3}

In [30]: result = pd.concat(pieces)

In [31]: result = pd.concat(pieces, keys=["z", "y"])

结果中创建了 MultiIndex，最外层为 keys 参数指定的值，而原 DataFrame 的索引在内层保留了下来

In [32]: result.index.levels
Out[32]: FrozenList([['z', 'y'], [4, 5, 6, 7, 8, 9, 10, 11]])

如果你想指定其他级别，可以使用 levels 参数:

In [33]: result = pd.concat(
   ....:     pieces, keys=["x", "y", "z"], levels=[["z", "y", "x", "w"]], names=["group_key"]
   ....: )
   ....: 

In [34]: result.index.levels
Out[34]: FrozenList([['z', 'y', 'x', 'w'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])

6 将行追加到DataFrame

虽然这样做效率很低，但是你可以通过传递一个 Series 或 dict 并将其追加到 DataFrame 中，同时会返回一个新的 DataFrame

In [35]: s2 = pd.Series(["X0", "X1", "X2", "X3"], index=["A", "B", "C", "D"])

In [36]: result = df1.append(s2, ignore_index=True)

你应该使用 ignore_index 来指示 DataFrame 丢弃它的索引。

如果你希望保留索引，你应该为 DataFrame 构造一个合适的索引，然后追加或连接这些对象

你也可以传递字典或 Series 列表:

In [37]: dicts = [{"A": 1, "B": 2, "C": 3, "X": 4}, {"A": 5, "B": 6, "C": 7, "Y": 8}]

In [38]: result = df1.append(dicts, ignore_index=True, sort=False)