在Pandas的实践过程中，我们经常需要将两个DataFrame合并组合在一起再进行处理，比如将不同来源的数据合并在一起，或者将不同日期的DataFrame合并在一起。DataFrame的合并组合从方向上分，大体上分为两种情况：横向的，纵向的。（这个很容易理解吧）
看下如下的图示（图片来自Pandas官网）
另外需要注意的是，两个DataFrame在合在一起的时候，如果针对重叠项（比如都有column B)会有两种不同的处理方式，一种是针对重叠项进行合并处理（比如相加，或者直接取代）；另一种是忽略重叠项，只是简单的组合在一起。前者我们称为合并，后者我们叫做组合。
另外，在Pandas中有很多不同函数和不同用法，比如有concat, join, merge, append，它们各有不同的使用场景。
纵向连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45In [45]: import pandas as pd
In [46]: df = pd.DataFrame({"name": ["zhangsan", "lisi", "wangwu"], "city": ["beijing"
...: , "beijing", "shenzhen"], "order": [12, 33, 67]})
In [47]: df
Out[47]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
In [48]: df2 = pd.DataFrame({"name": ["zhanghai", "liyang", "wangjing"], "city": ["sha
...: nghai", "shenzhen", "chengdu"], "order": [2, 3, 7]})
In [49]: df2
Out[49]:
city name order
0 shanghai zhanghai 2
1 shenzhen liyang 3
2 chengdu wangjing 7
# concat默认按行拼接(即纵向连接，axis=0), 也可以按列来连接(axis=1)
# 注意concat拼接时，其参数是一个数组 ，因此可以拼接多个DataFrame
In [51]: pd.concat([df, df2])
Out[51]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
0 shanghai zhanghai 2
1 shenzhen liyang 3
2 chengdu wangjing 7
# append是concat的一种快捷方式，用于将两个DataFrame直接拼接在一起
# append的参数即可以是一个DataFrame，也可以是一个数组，这种情况下可以合并多个DataFrame
In [52]: df.append(df2)
Out[52]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
0 shanghai zhanghai 2
1 shenzhen liyang 3
2 chengdu wangjing 7
横向连接与合并
前面我们已经知道concat不仅可以纵向连接，也可以横向连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40In [8]: df3 = pd.concat([df, df2], join="inner", axis=1)
In [9]: df3
Out[9]:
city name order city name order
0 beijing zhangsan 12 shanghai zhanghai 2
1 beijing lisi 33 shenzhen liyang 3
2 shenzhen wangwu 67 chengdu wangjing 7
# 实际上，concat是通过index来作为拼接的依据，什么意思呢，看下面的例子
# 我们重新assign index给df3
In [12]: df3 = pd.DataFrame({"name": ["zhanghai", "liyang", "wangjing"], "city": ["shanghai", "shenzhen", "chengdu"], "order": [2, 3, 7]}, index=[
...: 1, 3, 9])
# df3的row index变为了1， 3， 9
In [13]: df3
Out[13]:
city name order
1 shanghai zhanghai 2
3 shenzhen liyang 3
9 chengdu wangjing 7
# 当使用join="outer"的时候，取index的并集，index相同的行会放在同一行，而不同的行会分别列出
In [14]: df4 = pd.concat([df, df3], join="outer", axis=1)
In [15]: df4
Out[15]:
city name order city name order
0 beijing zhangsan 12.0 NaN NaN NaN
1 beijing lisi 33.0 shanghai zhanghai 2.0
2 shenzhen wangwu 67.0 NaN NaN NaN
3 NaN NaN NaN shenzhen liyang 3.0
9 NaN NaN NaN chengdu wangjing 7.0
# 当join="inner"时，我们取交集，index相同的行才会拼接在一起
In [16]: df5 = pd.concat([df, df3], join="inner", axis=1)
In [17]: df5
Out[17]:
city name order city name order
1 beijing lisi 33 shanghai zhanghai 2
我们看到concat仍然是一种拼接，其根据index进行join，而merge更加灵活，可以根据指定的column来进行合并，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27In [18]: df
Out[18]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
In [19]: df2
Out[19]:
city name order
1 shanghai zhanghai 2
3 shenzhen liyang 3
9 chengdu wangjing 7
# 根据指定的列"city"进行合并，同时how="outer"意味着join的方式
# on也可以跟一个list，这样就可以针对多个列进行join
In [21]: df6 = df.merge(df2, on="city", how="outer")
# 注意同名的列（非on column)，会默认添加"_x", "_y"后缀
In [22]: df6
Out[22]:
city name_x order_x name_y order_y
0 beijing zhangsan 12.0
1 beijing lisi 33.0
2 shenzhen wangwu 67.0 liyang 3.0
3 shanghai zhanghai 2.0
4 chengdu wangjing 7.0
可以针对多个列进行join，并重新命名后缀，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26In [31]: df2
Out[31]:
city name order
1 shanghai zhanghai 2
3 shenzhen liyang 67
9 chengdu wangjing 33
In [32]: df
Out[32]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
# 这里针对column "city" 和 "order"进行join
# 同时我们可以通过suffixes来为同名的列赋予更有意义的名字
In [35]: df7 = df.merge(df2, on=["city", "order"], how="outer", suffixes=('_left', '_right'))
In [36]: df7
Out[36]:
city name_left order name_right
0 beijing zhangsan 12 NaN
1 beijing lisi 33 NaN
2 shenzhen wangwu 67 liyang
3 shanghai NaN 2 zhanghai
4 chengdu NaN 33 wangjing
关于merge还有几个常用的参数说明如下： left_index & right_index: 当我们需要通过index来进行join的时候（类似concat），则可以使用left_index 或者right_index. sort: 默认为False，如果True则将join的key按照字典顺序进行排序，比如我们按照"city"进行join的时候，会按照"city"的字典顺序进行排序。但如果我们不需要排序，则可以将其置为False，以提高性能 validate: 主要针对duplicate的情况，它有以下几个参数可以设置 “one_to_one” or “1:1”: checks if merge keys are unique in both left and right datasets. “one_to_many” or “1:m”: checks if merge keys are unique in left dataset. “many_to_one” or “m:1”: checks if merge keys are unique in right dataset. “many_to_many” or “m:m”: allowed, but does not result in checks. 更多关于merge的说明参考如下链接： 关于merge的说明
另外，join是merge的一种简便写法，其底层是通过merge来实现的，如下两种表达方式是相同的。
1
2
3left.join(right, on=key_or_keys)
pd.merge(left, right, left_on=key_or_keys, right_index=True,
how='left', sort=False)
示例：
1
2
3
4
5
6
7
8
9
10
11
12# 示例来自官网
In [85]: left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3'],
....: 'key': ['K0', 'K1', 'K0', 'K1']})
....:
In [86]: right = pd.DataFrame({'C': ['C0', 'C1'],
....: 'D': ['D0', 'D1']},
....: index=['K0', 'K1'])
....:
In [87]: result = left.join(right, on='key')
需要注意的是当要join的两个DataFrame有同名的列时，必须指定suffix，否则会报错，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20In [45]: df
Out[45]:
city name order
0 beijing zhangsan 12
1 beijing lisi 33
2 shenzhen wangwu 67
In [46]: df2
Out[46]:
city name order
1 shanghai zhanghai 2
3 shenzhen liyang 67
9 chengdu wangjing 33
In [47]: df.join(df2, lsuffix="_left", rsuffix="_right")
Out[47]:
city_left name_left order_left city_right name_right order_right
0 beijing zhangsan 12 NaN NaN NaN
1 beijing lisi 33 shanghai zhanghai 2.0
2 shenzhen wangwu 67 NaN NaN NaN