Pandas数据分析-数据merge/join/concat,

(2023.04.30-05.01、05 Sun, Fri @KLN)
Pandas内置了三种用于数据整合的方法merge，join和concat。

merge

pandas中内置的merge()方法其功能类似于数据库操作语言SQL中的join，相比如后面提到的join和concat方法最灵活。对有共有数据的行做结合，merge()是最有效的方法。

merge()有“多对一”和“多对多”两种方式对数据做连接。这里的“多”指被连接的列中的值不唯一。

使用merge()方法需要提供

• 左DataFrame
• 右DataFrame

除此之外向merge()方法提供若干可选参数用于定义操作，常用的包括：

• how：定义merge的类型，默认为inner，其他选项包括outer，left，和right
• on：可选参数，用于执行join的列或索引，也称为关键列或关键索引(key columns/index)。如果未指定，则left_index和right_index值为False，且两个dataframe中有相同名字的列用于执行join操作。如果使用on参数，则指明的列/索引必须同时出现在两个dataframe中。关键列/索引可以多于一个。
• left_index和right_index：使用left或right的索引执行join操作，则将对应的变量设置为True，默认状态下是False
• left_on和right_on：指明有一个只在left或right的列/索引，默认情况下设置为None
• suffixes：一个字符tuple，加在相同列名之后这些列不作为merge的键，可用于追踪拥有相同名字的原始列

默认情况下，在执行merge操作时，两个DataFrame拥有相同名字的列用于作为执行join的key。

在执行inner join操作时，仅保留两个DataFrame关键列中有相同值的行，其他行则被放手。

examples

以默认参数执行join操作

>> df1 = pd.DataFrame({'a': [1,2,3,4,5,6,7,8,9,10], 'b':[59,60,61,62,63,64,65,66,67,68]})
>> df2 = pd.DataFrame({'a': [5,6,7,8,9,11,12,13,14,15,16], 'c':[101,102,103,104,105,106,107,108,109,110,111]})
>> pd.merge(df1,df2)
   a   b    c
0  5  63  101
1  6  64  102
2  7  65  103
3  8  66  104
4  9  67  105

指定特定列作为关键列。在下面案例中，在df2中添加一个列d，该列与df1中的列a有值重合。在merge中指定left_on=['a'], right_on=['d']。返回结果中的行满足a和d这两个关键列中的相同部分值。同时列名相同的列加了后缀用以区分

>> df2['d'] = [8,9,50,51,52,53,54,55,56,57,58]
>> df2
     a    c   d
0    5  101   8
1    6  102   9
2    7  103  50
3    8  104  51
4    9  105  52
5   11  106  53
6   12  107  54
7   13  108  55
8   14  109  56
9   15  110  57
10  16  111  58
>> pd.merge(df1, df2, left_on=['a'], right_on=['d'])
   a_x   b  a_y    c  d
0    8  66    5  101  8
1    9  67    6  102  9

对两个DataFrame使用outer方式做join，在merge的参数how设置为'outer'，如how="outer"。

>> pd.merge(df1, df2, how='outer')
     a     b      c     d
0    1  59.0    NaN   NaN
1    2  60.0    NaN   NaN
2    3  61.0    NaN   NaN
3    4  62.0    NaN   NaN
4    5  63.0  101.0   8.0
5    6  64.0  102.0   9.0
6    7  65.0  103.0  50.0
7    8  66.0  104.0  51.0
8    9  67.0  105.0  52.0
9   10  68.0    NaN   NaN
10  11   NaN  106.0  53.0
11  12   NaN  107.0  54.0
12  13   NaN  108.0  55.0
13  14   NaN  109.0  56.0
14  15   NaN  110.0  57.0
15  16   NaN  111.0  58.0

除此之外还有left和right两种join方式。

merge是Pandas中最复杂的数据整合工具，也是其他数据整合工具的基础。后面使用的join是一个简化版的merge()。

(2023.05.06 Sat @KLN HK)

join:

不同于merge，DataFrame的实例方法join更加易用，以DataFrame的index作为关键列/索引执行两个df的整合。在执行join时，所有列都被保存在最终结果中，即便有相同的名字。

join使用DataFrame的index作为连接两个DataFrame的字段/列，这是join和merge的最大区别，merge使用特定列作连接。

join是DataFrame的实例方法，在执行操作时使用

df_1.join(df_2,...)

的格式。

有若干参数可以设置

• other：唯一的required parameter，指明一个需要被整合的DataFrame，也可指明一个DataFrame的list
• on：optional，列出left DataFrame的的特定列/索引名用于和另一个DataFrame做join。如果设置为None，则代表默认，执行index-on-index join
• how：与merge的同名参数作用相同，差别在于这里是基于index，除非特别指明列
• lsuffix和rsuffix：类似merge中的suffix参数，指明了在重名情况下的名字后缀。但对DataFrame的列表无效
• sort：对结果的DataFrame排序，按照join key

>> df1.join(df2, lsuffix="_left", rsuffix='_right')
   a_left   b  a_right    c   d
0       1  59        5  101   8
1       2  60        6  102   9
2       3  61        7  103  50
3       4  62        8  104  51
4       5  63        9  105  52
5       6  64       11  106  53
6       7  65       12  107  54
7       8  66       13  108  55
8       9  67       14  109  56
9      10  68       15  110  57

concat

concat拼接不同于前面提到的merge技术。执行merge操作，得到的DataFrame有着母数据集(parent datasets)的行，基于母数据集的共同点(commonality)。而concat拼接操作则按照行或列方向将数据集拼接在一起。

格式为

df = pandas.concat([df1, df2])

默认情况下，df1和df2做纵向拼接

>> pd.concat([df1, df2])
     a     b      c     d
0    1  59.0    NaN   NaN
1    2  60.0    NaN   NaN
2    3  61.0    NaN   NaN
3    4  62.0    NaN   NaN
4    5  63.0    NaN   NaN
5    6  64.0    NaN   NaN
6    7  65.0    NaN   NaN
7    8  66.0    NaN   NaN
8    9  67.0    NaN   NaN
9   10  68.0    NaN   NaN
0    5   NaN  101.0   8.0
1    6   NaN  102.0   9.0
2    7   NaN  103.0  50.0
3    8   NaN  104.0  51.0
4    9   NaN  105.0  52.0
5   11   NaN  106.0  53.0
6   12   NaN  107.0  54.0
7   13   NaN  108.0  55.0
8   14   NaN  109.0  56.0
9   15   NaN  110.0  57.0
10  16   NaN  111.0  58.0

通过设置参数axis="columns"，可使得两个DataFrame沿着横向拼接

>> pd.concat([df1, df2], axis='columns')
       a     b   a    c   d
0    1.0  59.0   5  101   8
1    2.0  60.0   6  102   9
2    3.0  61.0   7  103  50
3    4.0  62.0   8  104  51
4    5.0  63.0   9  105  52
5    6.0  64.0  11  106  53
6    7.0  65.0  12  107  54
7    8.0  66.0  13  108  55
8    9.0  67.0  14  109  56
9   10.0  68.0  15  110  57
10   NaN   NaN  16  111  58

concat操作会生成一个拼接形成的数据副本，当使用多次concat()操作时会产生性能问题，为避免这个问题可在concat内置的copy参数设置为False

默认设置下，concat操作相当于求并集(set union)，所有数据都被保留。在merge和join中需要指定特定参数才能实现。

主要参数

• objs：常用list形式，接受DataFrame或Series对象用于拼接。也可提供字典，字典的键将用于构建分级索引(hierarchical index)
• axis：用于拼接数据的轴向，默认为0，沿着索引或行轴方向拼接。值为1时纵向拼接，或沿着列。值也可以是"index"或"columns"
• join：类似join和merge中的how参数，但只接受inner和outer两个值，默认为outer，用于保留数据，而inner则会删除另一个数据集中不匹配的数据
• ignore_index：boolean类型，默认为False。值为True时，则新合成的数据集不会保留原始数据的索引值，并产生新的全新索引值
• keys：构建分级索引
• copy：是否保留原始数据源，默认为True。当设置为False时，pandas不会生成数据源的备份

对比

• merge()：通过共同的列或index将数据连接在一起，可以多个列/索引
• join()：通过单独的关键列(key column)或index将数据连接在一起
• concat()：在行向或列向将DataFrame连接在一起

Reference

1 realpython, Combining data in pandas with merge(), join() and concat(), Kyle Stratis