5个Pandas组合函数的异同
1. 阐明
在日常解决数据的时候，常常会遇到不同dataframe的连贯、组合等操作，刚开始用的时候，会有点蒙，毕竟上面几个函数的作用相似，容易产生混同。
concat
join
merge
combine
append
上面用最简略的示例进行解释、辨别几个函数的作用。
>>> import pandas as pd>>> df0 = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})>>> df0 a b0 1 41 2 52 3 6>>> df1 = pd.DataFrame({"c": [2, 3, 4], "d": [5, 6, 7]})>>> df1 c d0 2 51 3 62 4 72. concat
concat，全拼 “concatenation”，容许程度或垂直地并排组合数据。
2.1 行拼接
当合并具备雷同列的数据时（2个df列名保持一致，行拼接），能够通过指定轴为 0（默认值） 来调用。
当axis=0应了解为，在列的方向进行拼接（向下进行拼接），也就是按行拼接起来。
列名需保持一致，失去的才是想要的行拼接，df1.rename(columns={"c": "a", "d": "b"})。
>>> pd.concat([df0, df1.rename(columns={"c": "a", "d": "b"})] , axis=0) a b0 1 41 2 52 3 60 2 51 3 62 4 7如果列名不统一，则得不到想要的行拼接后果。
In [9]: pd.concat([df0,df1],axis=0)Out[9]: a b c d0 1.0 4.0 NaN NaN1 2.0 5.0 NaN NaN2 3.0 6.0 NaN NaN0 NaN NaN 2.0 5.01 NaN NaN 3.0 6.02 NaN NaN 4.0 7.0小结：
行拼接，如果不产生多余的列，留神列名保持一致
2.2 列拼接
按列拼接，axis=1能够了解为，在行的方向进行拼接（向右进行拼接），也就是将列拼接起来。
>>> pd.concat([df0, df1], axis=1) a b c d0 1 4 2 51 2 5 3 62 3 6 4 7在默认状况下，当程度组合数据（即沿列）时，会尝试应用索引。当它们不雷同时，会看到 NaN 填充不重叠的数据，如下所示：
>>> df2 = df1.copy()>>> df2.index = [1, 2, 3]>>> pd.concat([df0, df2], axis=1) a b c d0 1.0 4.0 NaN NaN1 2.0 5.0 2.0 5.02 3.0 6.0 3.0 6.03 NaN NaN 4.0 7.0如果想对立索引进行拼接，就必须先重置它们的索引：
>>> pd.concat([df0.reset_index(drop=True), df2.reset_index(drop=True)], axis=1) a b c d0 1 4 2 51 2 5 3 62 3 6 4 7小结：
列拼接，如果不产生多余的行，留神索引保持一致
3. join
与 concat 相比，join 专门用于应用索引连贯DataFrame对象之间的列。
df0,df1的索引统一：
>>> df0.join(df1) a b c d0 1 4 2 51 2 5 3 62 3 6 4 7当索引不统一，连贯默认保留来自左侧 DataFrame 的行（默认左表是驱动表）；如果右侧DataFrame中没有左侧DataFrame中匹配索引的行，右侧DataFrame被删除、用Null填充，如下所示：
>>> df0.join(df2) a b c d0 1 4 NaN NaN1 2 5 2.0 5.02 3 6 3.0 6.0还能够通过设置 how 参数来更改驱动表，也就是SQL中的几种关联连贯。
# "right" uses df2’s index>>> df0.join(df2, how="right") a b c d1 2.0 5.0 2 52 3.0 6.0 3 63 NaN NaN 4 7# "outer" uses the union>>> df0.join(df2, how="outer") a b c d0 1.0 4.0 NaN NaN1 2.0 5.0 2.0 5.02 3.0 6.0 3.0 6.03 NaN NaN 4.0 7.0# "inner" uses the intersection>>> df0.join(df2, how="inner") a b c d1 2 5 2 52 3 6 3 6小结：
join是基于索引的连贯，只有列连贯，与sql的关联相似
4. merge
与join相比，merge更为通用，能够对列和索引执行合并操作。
在a列上进行内关联：
>>> df0.merge(df1.rename(columns={"c": "a"}), on="a", how="inner") a b d0 2 5 51 3 6 6如果想同时保留关联列，则能够这样写：
>>> df0.merge(df1, left_on="a", right_on="c") a b c d0 2 5 2 51 3 6 3 6当两个 DataFrame 对象具备雷同的列，而不是要合并时，suffixes参数设置这些列重命名的后缀；默认状况下，左、右数据框的后缀别离是“_x”和“_y”，也能够自定义。
>>> df0.merge(df1.rename(columns={"c": "a", "d": "b"}), on="a", how="outer", suffixes=("_l", "_r")) a b_l b_r0 1 4.0 NaN1 2 5.0 5.02 3 6.0 6.03 4 NaN 7.05. combine
combine函数也是作用于2个DataFrame对象之间，按列组合，但它与下面几个函数有很大不同。
combine函数的非凡之处在于它须要一个函数参数。此函数采纳两个series，每个series对应于每个 DataFrame 中的合并列，并返回一个series作为雷同列的元素操作的最终值。
有点绕，看个示例：
>>> def taking_larger_square(s1, s2):... return s1 * s1 if s1.sum() > s2.sum() else s2 * s2>>> df0.combine(df1.rename(columns={"c": "a", "d": "b"}), taking_larger_square) a b0 4 251 9 362 16 49take_larger_square 函数对 df0 和 df1 中的 a 列以及 df0 和 df1 中的 b 列进行操作。 在两列 a 和两列 b 之间，taking_larger_square 取较大列中值的平方。 在这种状况下，df1 的 a 和 b 列将作为平方，产生最终值，这里恰好是df1的a、b都大于df0的a、b，如果df1中的一个大、一个小，则还是取最大的那个作为平方。
In [13]: df0,df1Out[13]:( a b 0 1 2 1 2 3 2 3 4, c d 0 4 1 1 5 2 2 6 3) In [11]: df0.combine(df1.rename(columns={"c": "a", "d": "b"}), taking_larger_square)Out[11]: a b0 16 41 25 92 36 16小结：
用combine进行组合，次要是针对2个DataFrame对象中的series进行函数解决，取其一作为后果。
6. append
append 函数专门用于将行追加到现有 DataFrame 对象，创立一个新对象。
>>> df0.append(df1.rename(columns={"c": "a", "d": "b"})) a b0 1 41 2 52 3 60 2 51 3 62 4 7这和concat( ,axis=0)成果一样。
append 的独特之处在于还能够追加 dict 对象，这为咱们提供了追加不同类型数据的灵活性。留神，必须将 ignore_index 设置为 True，因为dict对象没有 DataFrame 能够应用的索引信息。
>>> df0.append({"a": 1, "b": 2}, ignore_index=True) a b0 1 41 2 52 3 63 1 27. 总结
- concat：按行和按列组合数据
- join：应用索引，按行合并数据
- merge：按列合并数据，更像数据库连贯操作
- combine：按列合并数据，具备列间（雷同列）元素操作
- append：以DataFrame或dict对象的模式逐行追加数据
欢送关注集体公众号：Distinct数说