前言
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)
