pandas数据的行更新、表合并等操作，一般用到的方法有concat、join、merge。本篇先说concat方法。其具体用法如下：

1pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
2       keys=None, levels=None, names=None, verify_integrity=False)

常用参数说明：

  • objs: series，dataframe或者是panel构成的序列lsit
  • axis： 需要合并链接的轴，0是行，1是列
  • join：连接的方式 inner，或者outer。inner取两表的交集；outer取两表的并集。

一、相同字段的表首尾相接

 1import pandas as pd
 2df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
 3                    'B': ['B0', 'B1', 'B2', 'B3'],
 4                    'C': ['C0', 'C1', 'C2', 'C3'],
 5                    'D': ['D0', 'D1', 'D2', 'D3']},
 6                   index=[0, 1, 2, 3])
 7print(df1)
 8print('---------------------------------')
 9df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
10                    'B': ['B4', 'B5', 'B6', 'B7'],
11                    'C': ['C4', 'C5', 'C6', 'C7'],
12                    'D': ['D4', 'D5', 'D6', 'D7']},
13                   index=[4, 5, 6, 7])
14print(df2)
15print('---------------------------------')
16df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
17                    'B': ['B8', 'B9', 'B10', 'B11'],
18                    'C': ['C8', 'C9', 'C10', 'C11'],
19                    'D': ['D8', 'D9', 'D10', 'D11']},
20                   index=[8, 9, 10, 11])
21print(df3)
22print('---------------------------------')
23frames = [df1, df2, df3]
24result = pd.concat(frames)
25print(result)

执行合并后结果如下：

 1A   B   C   D
 20  A0  B0  C0  D0
 31  A1  B1  C1  D1
 42  A2  B2  C2  D2
 53  A3  B3  C3  D3
 6---------------------------------
 7    A   B   C   D
 84  A4  B4  C4  D4
 95  A5  B5  C5  D5
106  A6  B6  C6  D6
117  A7  B7  C7  D7
12---------------------------------
13      A    B    C    D
148    A8   B8   C8   D8
159    A9   B9   C9   D9
1610  A10  B10  C10  D10
1711  A11  B11  C11  D11
18---------------------------------
19      A    B    C    D
200    A0   B0   C0   D0
211    A1   B1   C1   D1
222    A2   B2   C2   D2
233    A3   B3   C3   D3
244    A4   B4   C4   D4
255    A5   B5   C5   D5
266    A6   B6   C6   D6
277    A7   B7   C7   D7
288    A8   B8   C8   D8
299    A9   B9   C9   D9
3010  A10  B10  C10  D10
3111  A11  B11  C11  D11

如要在相接的时候在加上一个层次的key来识别数据源自于哪张表，可以增加key参数

1result2 = pd.concat(frames, keys=['x', 'y', 'z'])
2print(result2)

执行后输出结果如下：

 1  A    B    C    D
 2x 0    A0   B0   C0   D0
 3  1    A1   B1   C1   D1
 4  2    A2   B2   C2   D2
 5  3    A3   B3   C3   D3
 6y 4    A4   B4   C4   D4
 7  5    A5   B5   C5   D5
 8  6    A6   B6   C6   D6
 9  7    A7   B7   C7   D7
10z 8    A8   B8   C8   D8
11  9    A9   B9   C9   D9
12  10  A10  B10  C10  D10
13  11  A11  B11  C11  D11

此时可以通过增加的key信息取得相应的数据。

1print(result2.loc['y'])
2输出结果如下：
3    A   B   C   D
44   A4  B4  C4  D4
55   A5  B5  C5  D5
66   A6  B6  C6  D6
77   A7  B7  C7  D7

二、横向拼接

1、axis

这里再创建一个测试用的数据，使用axis=1表示进行横向拼接。即列拼接。

1df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'],
2                    'D': ['D2', 'D3', 'D6', 'D7'],
3                    'F': ['F2', 'F3', 'F6', 'F7']},
4                   index=[2, 3, 6, 7])
5result3 = pd.concat([df1, df4], axis=1)
6print(result3)

合并后的结果如下：

1     A    B    C    D    B    D    F
20   A0   B0   C0   D0  NaN  NaN  NaN
31   A1   B1   C1   D1  NaN  NaN  NaN
42   A2   B2   C2   D2   B2   D2   F2
53   A3   B3   C3   D3   B3   D3   F3
66  NaN  NaN  NaN  NaN   B6   D6   F6
77  NaN  NaN  NaN  NaN   B7   D7   F7

2、 join

join参数有outer和inner两种连接方式，前者表示外连接，后者表示内连接。其中一个是取交集一个是取并集，这个在全文开始的时候已经说明：

1result = pd.concat([df1, df4], axis=1, join='inner')
2print(result)

执行结果如下：

1    A   B   C   D   B   D   F
22  A2  B2  C2  D2  B2  D2  F2
33  A3  B3  C3  D3  B3  D3  F3

3、 join_axes

如果有join_axes的参数传入，可以指定根据那个轴来对齐数据。例如根据df1表对齐数据，就会保留指定的df1表的轴，然后将df4的表与之拼接：

1result = pd.concat([df1, df4], axis=1, join_axes=[df1.index])
2print(result)

执行后输出结果如下：

1    A   B   C   D    B    D    F
20  A0  B0  C0  D0  NaN  NaN  NaN
31  A1  B1  C1  D1  NaN  NaN  NaN
42  A2  B2  C2  D2   B2   D2   F2
53  A3  B3  C3  D3   B3   D3   F3

从上面的输出来看，df4对接的索引6、7两行的值并未合并在一起。

三、append

append是series和dataframe的方法，使用它就是默认沿着列进行凭借（axis = 0，列对齐行合并）

 1result = df1.append(df4)
 2print(result)
 3输出结果如下：
 4     A   B    C   D    F
 50   A0  B0   C0  D0  NaN
 61   A1  B1   C1  D1  NaN
 72   A2  B2   C2  D2  NaN
 83   A3  B3   C3  D3  NaN
 92  NaN  B2  NaN  D2   F2
103  NaN  B3  NaN  D3   F3
116  NaN  B6  NaN  D6   F6
127  NaN  B7  NaN  D7   F7

四、忽略index的concat

如果两个表的index都没有实际含义，使用ignore_index参数，置true，合并的两个表就会根据列字段对齐，然后合并。最后再重新整理一个新的index。

 1result = pd.concat([df1, df4], ignore_index=True)
 2print(result)
 3执行结果如下：
 4     A   B    C   D    F
 50   A0  B0   C0  D0  NaN
 61   A1  B1   C1  D1  NaN
 72   A2  B2   C2  D2  NaN
 83   A3  B3   C3  D3  NaN
 94  NaN  B2  NaN  D2   F2
105  NaN  B3  NaN  D3   F3
116  NaN  B6  NaN  D6   F6
127  NaN  B7  NaN  D7   F7

这个也可以使用append，两者执行的结果是等价的，上面的语句执行的结果的结果和如下的相同：

1result = df1.append(df4, ignore_index=True)

五、混合合并

可以使用Series 和DataFrame 两种类型的对象进行合并：

1s1 = pd.Series(['X0', 'X1', 'X2', 'X3'], name='X')
2result = pd.concat([df1, s1], axis=1)
3print(result)
4执行结果如下：
5    A   B   C   D   X
60  A0  B0  C0  D0  X0
71  A1  B1  C1  D1  X1
82  A2  B2  C2  D2  X2
93  A3  B3  C3  D3  X3

同样也可以执行多次合并，如下：

1s2 = pd.Series(['_0', '_1', '_2', '_3'])
2result = pd.concat([df1, s2, s2, s2], axis=1)
3print(result)
4执行结果如下：
5    A   B   C   D   0   1   2
60  A0  B0  C0  D0  _0  _0  _0
71  A1  B1  C1  D1  _1  _1  _1
82  A2  B2  C2  D2  _2  _2  _2
93  A3  B3  C3  D3  _3  _3  _3

上面我们也提到了ignore_index，同样也可以对列名称进行忽略操作，使用索引号如下：

1result = pd.concat([df1, s1], axis=1, ignore_index=True)
2print(result)
3执行结果如下：
4    0   1   2   3   4
50  A0  B0  C0  D0  X0
61  A1  B1  C1  D1  X1
72  A2  B2  C2  D2  X2
83  A3  B3  C3  D3  X3

六、增加key参数的合并

增加key参数主要是便于区分合并前的数据。这个前面已经提了一种直接使用key参数，另外还有一种可以使用字典的方式实现区分合并前的值:

11、直接用key参数实现:
2result = pd.concat(frames, keys=['x', 'y', 'z'])
32、传入字典来增加分组键
4pieces = {'x': df1, 'y': df2, 'z': df3}
5result = pd.concat(pieces)

参考页面：官方文档