共计 3278 个字符,预计需要花费 9 分钟才能阅读完成。
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 b
0 1 4
1 2 5
2 3 6
>>> df1 = pd.DataFrame({"c": [2, 3, 4], "d": [5, 6, 7]})
>>> df1
c d
0 2 5
1 3 6
2 4 7
2. 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 b
0 1 4
1 2 5
2 3 6
0 2 5
1 3 6
2 4 7
如果列名不统一,则得不到想要的行拼接后果。
In [9]: pd.concat([df0,df1],axis=0)
Out[9]:
a b c d
0 1.0 4.0 NaN NaN
1 2.0 5.0 NaN NaN
2 3.0 6.0 NaN NaN
0 NaN NaN 2.0 5.0
1 NaN NaN 3.0 6.0
2 NaN NaN 4.0 7.0
小结:
行拼接,如果不产生多余的列,留神列名保持一致
2.2 列拼接
按列拼接,axis=1
能够了解为,在行的方向进行拼接(向右进行拼接),也就是将列拼接起来。
>>> pd.concat([df0, df1], axis=1)
a b c d
0 1 4 2 5
1 2 5 3 6
2 3 6 4 7
在默认状况下,当程度组合数据(即沿列)时,会尝试应用索引。当它们不雷同时,会看到 NaN 填充不重叠的数据,如下所示:
>>> df2 = df1.copy()
>>> df2.index = [1, 2, 3]
>>> pd.concat([df0, df2], axis=1)
a b c d
0 1.0 4.0 NaN NaN
1 2.0 5.0 2.0 5.0
2 3.0 6.0 3.0 6.0
3 NaN NaN 4.0 7.0
如果想对立索引进行拼接,就必须先重置它们的索引:
>>> pd.concat([df0.reset_index(drop=True),
df2.reset_index(drop=True)], axis=1)
a b c d
0 1 4 2 5
1 2 5 3 6
2 3 6 4 7
小结:
列拼接,如果不产生多余的行,留神索引保持一致
3. join
与 concat 相比,join 专门用于 应用索引连贯 DataFrame 对象之间的列
。
df0,df1 的索引统一:
>>> df0.join(df1)
a b c d
0 1 4 2 5
1 2 5 3 6
2 3 6 4 7
当索引不统一,连贯默认保留来自左侧 DataFrame 的行(默认左表是驱动表);如果右侧 DataFrame 中没有左侧 DataFrame 中匹配索引的行,右侧 DataFrame 被删除、用 Null 填充,如下所示:
>>> df0.join(df2)
a b c d
0 1 4 NaN NaN
1 2 5 2.0 5.0
2 3 6 3.0 6.0
还能够通过设置 how 参数来更改驱动表,也就是 SQL 中的几种关联连贯。
# "right" uses df2’s index
>>> df0.join(df2, how="right")
a b c d
1 2.0 5.0 2 5
2 3.0 6.0 3 6
3 NaN NaN 4 7# "outer" uses the union
>>> df0.join(df2, how="outer")
a b c d
0 1.0 4.0 NaN NaN
1 2.0 5.0 2.0 5.0
2 3.0 6.0 3.0 6.0
3 NaN NaN 4.0 7.0# "inner" uses the intersection
>>> df0.join(df2, how="inner")
a b c d
1 2 5 2 5
2 3 6 3 6
小结:
join 是基于索引的连贯,只有列连贯,与 sql 的关联相似
4. merge
与 join 相比,merge 更为通用,能够对列和索引执行合并操作。
在 a 列上进行内关联:
>>> df0.merge(df1.rename(columns={"c": "a"}),
on="a", how="inner")
a b d
0 2 5 5
1 3 6 6
如果想同时保留关联列,则能够这样写:
>>> df0.merge(df1, left_on="a", right_on="c")
a b c d
0 2 5 2 5
1 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_r
0 1 4.0 NaN
1 2 5.0 5.0
2 3 6.0 6.0
3 4 NaN 7.0
5. 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 b
0 4 25
1 9 36
2 16 49
take_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,df1
Out[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 b
0 16 4
1 25 9
2 36 16
小结:
用 combine 进行组合,次要是针对 2 个 DataFrame 对象中的 series 进行函数解决,取其一作为后果。
6. append
append 函数专门用于 将行追加到现有 DataFrame 对象
,创立一个新对象。
>>> df0.append(df1.rename(columns={"c": "a", "d": "b"}))
a b
0 1 4
1 2 5
2 3 6
0 2 5
1 3 6
2 4 7
这和 concat(,axis=0)成果一样。
append 的独特之处在于还能够追加 dict 对象,这为咱们提供了追加不同类型数据的灵活性。留神,必须将 ignore_index 设置为 True,因为 dict 对象没有 DataFrame 能够应用的索引信息。
>>> df0.append({"a": 1, "b": 2}, ignore_index=True)
a b
0 1 4
1 2 5
2 3 6
3 1 2
7. 总结
- concat:按行和按列组合数据
- join:应用索引,按行合并数据
- merge:按列合并数据,更像数据库连贯操作
- combine:按列合并数据,具备列间(雷同列)元素操作
- append:以 DataFrame 或 dict 对象的模式逐行追加数据
欢送关注集体公众号:Distinct 数说