头图

5个Pandas组合函数的异同

没有蜡笔的小晞

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数说

阅读 179

Distinct数说
人总要跳出舒适区才能得到成长
6 声望
1 粉丝
0 条评论
6 声望
1 粉丝
文章目录
宣传栏