数据分析和建模方面的大量编程工作都是用在数据准备上的：载入、清理、转换以及重塑。有时候，存放在文件或数据库中的数据并不能满足你的数据处理应用的要求。很多人都选择使用通用编程语言（如Python、Perl、R或Java）或UNIX文本处理工具（如sed或awk）对数据格式进行专门处理。幸运的是，pandas和Python标准库提供了一组高级的、灵活的、高效的核心函数和算法，它们使你可以轻松地将数据规整化为正确的形式。
1、合并数据集
pandas对象中的数据能够通过一些内置的方式进行合并：
- pandas.merge可依据一个或多个键将不同DataFrame中的行连接起来。SQL或其它关系型数据库的用户对此应该会比較熟悉，由于它实现的就是数据库的连接操作。
- pandas.concat能够沿着一条轴将多个对象堆叠到一起。
- 实例方法combine_first能够将反复数据编接在一起，用一个对象中的值填充还有一个对象中的缺失值。
2、数据库风格的DataFrame合并
数据集的合并（merge）或连接（join）运算是通过一个或多个键将行链接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
In [4]: import pandas as pd
In [5]: import numpy as np
In [6]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
...: 'data1': range(7)})
In [7]: df2 = pd.DataFrame({'key': ['a', 'b', 'd'],
...: 'data2': range(3)})
In [8]: df1
Out[8]:
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 a
6 6 b
[7 rows x 2 columns]
In [9]: df2
Out[9]:
data2 key
0 0 a
1 1 b
2 2 d
[3 rows x 2 columns]
这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每一个值则仅相应一行。对这些对象调用merge就可以得到：
In [10]: pd.merge(df1, df2)
Out[10]:
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0 [6 rows x 3 columns]
注意，我并没有指明要用哪个列进行连接。假设没有指定，merge就会将重叠列的列名当做键。只是，最好显示指定一下：
In [11]: pd.merge(df1, df2, on='key')
Out[11]:
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0 [6 rows x 3 columns]
假设两个对象的列名不同，也能够分别进行指定：
In [12]: df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
....: 'data1': range(7)})
In [13]: df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],
....: 'data2': range(3)})
In [14]: pd.merge(df)
df1 df2 df3 df4
In [14]: pd.merge(df3, df4, left_on='lkey', right_on='rkey')
Out[14]:
data1 lkey data2 rkey
0 0 b 1 b
1 1 b 1 b
2 6 b 1 b
3 2 a 0 a
4 4 a 0 a
5 5 a 0 a
[6 rows x 4 columns]
可能你已经主要到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“inner”连接；结果中的键是交集。其它方式还有“left”、“right”以及“outer”。外连接求取的是键的交集，组合了左连接和右连接的效果：
In [16]: pd.merge(df1, df2, how='outer')
Out[16]:
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0
6 3 c NaN
7 NaN d 2 [8 rows x 3 columns]
多对多的合并操作很easy，无需额外的工作。例如以下所看到的：
In [17]: df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
....: 'data1': range(6)})
In [18]: df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],
....: 'data2': range(5)})
In [19]: df1
Out[19]:
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 b
[6 rows x 2 columns]
In [20]: df2
Out[20]:
data2 key
0 0 a
1 1 b
2 2 a
3 3 b
4 4 d
[5 rows x 2 columns]
In [21]: pd.merge(df1, df2, on='key', how='left')
Out[21]:
data1 key data2
0 0 b 1
1 0 b 3
2 1 b 1
3 1 b 3
4 5 b 1
5 5 b 3
6 2 a 0
7 2 a 2
8 4 a 0
9 4 a 2
10 3 c NaN
[11 rows x 3 columns]
多对多连接产生的是行的笛卡尔积。因为左边的DataFrame有3个“b”行，右边的有2个，所以终于结果中就有6个“b”行。连接方式仅仅影响出如今结果中的键：
In [23]: pd.merge(df1, df2, on='key', how='inner')
Out[23]:
data1 key data2
0 0 b 1
1 0 b 3
2 1 b 1
3 1 b 3
4 5 b 1
5 5 b 3
6 2 a 0
7 2 a 2
8 4 a 0
9 4 a 2 [10 rows x 3 columns]
要依据多个键进行合并，传入一个由列名组成的列表就可以：
In [24]: left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
....: 'key2': ['one', 'two', 'one'],
....: 'lval': [1, 2, 3]})
In [25]: right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
....: 'key2': ['one', 'one', 'one', 'two'],
....: 'rval': [4, 5, 6, 7]})
In [26]: pd.merge(left, right, on=['key1', 'key2'], how='outer')
Out[26]:
key1 key2 lval rval
0 foo one 1 4
1 foo one 1 5
2 foo two 2 NaN
3 bar one 3 6
4 bar two NaN 7
[5 rows x 4 columns]
结果中会出现哪些键组合取决于所选的合并方式，你能够这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并非这么回事）。
警告：
在进行列-列连接时，DataFrame对象中的索引会被丢弃。
对于合并运算须要须要考虑的最后一个问题是对反复列名的处理。尽管你能够手工处理列名重叠的问题，但merge有一个更有用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
In [27]: pd.merge(left, right, on='key1')
Out[27]:
key1 key2_x lval key2_y rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7 [6 rows x 5 columns] In [28]: pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
Out[28]:
key1 key2_left lval key2_right rval
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7 [6 rows x 5 columns]