7. 数据规整：聚合、合并、重塑和分组
文章目录
7. 数据规整：聚合、合并、重塑和分组数据规整：聚合、合并、重塑和分组1. 层次化索引重排与分级排序根据级别汇总统计使用DataFrame的列进行索引2. 合并数据集数据库风格的DataFrame合并索引上的合并轴向连接数据规整：聚合、合并、重塑和分组
在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。
1. 层次化索引
层次化索引（hierarchical indexing）是pandas的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：
import pandas as pdimport numpy as np
data = pd.Series(np.random.randn(9),index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],[1, 2, 3, 1, 3, 1, 2, 2, 3]])dataa 1 -0.2908392 2.3041093 1.634541b 1 0.5801543 0.467801c 1 1.8399852 -0.609232d 2 -0.2680563 -0.946874dtype: float64
看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”：
data.index-----------------------------------------------------------------------------MultiIndex([('a', 1),('a', 2),('a', 3),('b', 1),('b', 3),('c', 1),('c', 2),('d', 2),('d', 3)],)
对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：
MultiIndex([('a', 1),('a', 2),('a', 3),('b', 1),('b', 3),('c', 1),('c', 2),('d', 2),('d', 3)],)
data['b']-----------------------------------------------------------------------------1 0.5801543 0.467801dtype: float64data['b':'c']-----------------------------------------------------------------------------b 1 0.5801543 0.467801c 1 1.8399852 -0.609232dtype: float64data.loc[['b','d']]-----------------------------------------------------------------------------b 1 0.5801543 0.467801d 2 -0.2680563 -0.946874dtype: float64
有时甚至还可以在“内层”中进行选取：
data.loc[:,2]a 2.304109c -0.609232d -0.268056dtype: float64
层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：
data.unstack()123a-0.2908392.3041091.634541b0.580154NaN0.467801c1.839985-0.609232NaNdNaN-0.268056-0.946874
unstack的逆运算是stack
data.unstack().stack()
a 1 -0.2908392 2.3041093 1.634541b 1 0.5801543 0.467801c 1 1.8399852 -0.609232d 2 -0.2680563 -0.946874dtype: float64
对于一个DataFrame，每条轴都可以有分层索引：
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],columns=[['Ohio', 'Ohio', 'Colorado'],['Green', 'Red', 'Green']])
frameOhioColoradoGreenRedGreena10122345b1678291011
各层都可以有名字（可以是字符串，也可以是别的Python对象）。如果指定了名称，它们就会显示在控制台输出中：
frame.index.names = ['key1', 'key2']frame.columns.names = ['state', 'color']framestateOhioColoradocolorGreenRedGreenkey1key2a10122345b1678291011
有了部分列索引，因此可以轻松选取列分组：
frame['Ohio']colorGreenRedkey1key2a101234b1672910
可以单独创建MultiIndex然后复用。上面那个DataFrame中的（带有分级名称）列可以这样创建：
from pandas import MultiIndexMultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],names=['state', 'color'])MultiIndex([( 'Ohio', 'Green'),( 'Ohio', 'Red'),('Colorado', 'Green')],names=['state', 'color'])
重排与分级排序
有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：
frame.swaplevel('key1', 'key2')stateOhioColoradocolorGreenRedGreenkey2key11a0122a3451b6782b91011
而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：
frame.sort_index(level=1)stateOhioColoradocolorGreenRedGreenkey1key2a1012b1678a2345b291011
frame.swaplevel(0,1).sort_index(level=0)stateOhioColoradocolorGreenRedGreenkey2key11a012b6782a345b91011
根据级别汇总统计
许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例，我们可以根据行或列上的级别来进行求和：
frame.sum(level='key2')stateOhioColoradocolorGreenRedGreenkey2168102121416
framestateOhioColoradocolorGreenRedGreenkey1key2a10122345b1678291011
frame.sum(level='color', axis=1)colorGreenRedkey1key2a121284b11472
使用DataFrame的列进行索引
人们经常想要将DataFrame的一个或多个列当做行索引来用，或者可能希望将行索引变成DataFrame的列。以下面这个DataFrame为例：
frame = pd.DataFrame({'a': range(7), 'b': range(7, 0, -1),'c': ['one', 'one', 'one', 'two', 'two','two', 'two'],'d': [0, 1, 2, 0, 1, 2, 3]})frameabcd007one0116one1225one2334two0443two1552two2661two3
DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：
frame2 = frame.set_index(['c', 'd'])frame2abcdone007116225two034143252361
默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来：
frame.set_index(['c','d'], drop=False)abcdcdone007one0116one1225one2two034two0143two1252two2361two3
reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列里面：
frame2.reset_index()cdab0one0071one1162one2253two0344two1435two2526two361
2. 合并数据集
pandas对象中的数据可以通过一些方式进行合并：
pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的join操作。pandas.concat可以沿着一条轴将多个对象堆叠到一起。实例方法combine_first可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。
本节将分别对它们进行讲解，并给出一些例子。
数据库风格的DataFrame合并
数据集的合并（merge）或连接（join）运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库（基于SQL）的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
以一个简单的例子开始：
df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],'data1':range(7)})df2 = pd.DataFrame({'key':['a', 'b', 'd'],'data2': range(3)})df1keydata10b01b12a23c34a45a56b6df2keydata20a01b12d2
这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到：
pd.merge(df1, df2)keydata1data20b011b112b613a204a405a50
注意，这里并没有指明要用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当做键。不过，最好明确指定一下：
pd.merge(df1, df2, on='key')keydata1data20b011b112b613a204a405a50
如果两个对象的列名不同，也可以分别进行指定：
df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],'data1': range(7)})df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],'data2': range(3)})df3lkeydata10b01b12a23c34a45a56b6df4rkeydata20a01b12d2
pd.merge(df3, df4, left_on='lkey', right_on='rkey')lkeydata1rkeydata20b0b11b1b12b6b13a2a04a4a05a5a0
可能你已经注意到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“内连接”；结果中的键是交集。其他方式还有"left"、“right"以及"outer”。外连接求取的是键的并集，组合了左连接和右连接的效果：
pd.merge(df1, df2, how='outer')keydata1data20b0.01.01b1.01.02b6.01.03a2.00.04a4.00.05a5.00.06c3.0NaN7dNaN2.0
下表对这些选项进行了总结:
多对多的合并有些不直观。看下面的例子：
df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],'data1': range(6)})df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],'data2': range(5)})df1keydata10b01b12a23c34a45b5df2keydata20a01b12a23b34d4
pd.merge(df1, df2, on='key', how='left')keydata1data20b01.01b03.02b11.03b13.04a20.05a22.06c3NaN7a40.08a42.09b51.010b53.0
多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最终结果中就有6个"b"行。连接方式只影响出现在结果中的不同的键的值：
pd.merge(df1, df2, how='inner')key data1data20b011b032b113b134b515b536a207a228a409a42
要根据多个键进行合并，传入一个由列名组成的列表即可：
left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],'key2': ['one', 'two', 'one'],'lval': [1, 2, 3]})right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],'key2': ['one', 'one', 'one', 'two'],'rval': [4, 5, 6, 7]})
leftkey1key2lval0fooone11footwo22barone3rightkey1key2rval0fooone41fooone52barone63bartwo7pd.merge(left, right, on=['key1', 'key2'], how='outer')key1key2lvalrval0fooone1.04.01fooone1.05.02footwo2.0NaN3barone3.06.04bartwoNaN7.0
结果中会出现哪些键组合取决于所选的合并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
pd.merge(left, right, on='key1')key1key2_xlvalkey2_yrval0fooone1one41fooone1one52footwo2one43footwo2one54barone3one65barone3two7
pd.merge(left, right, on='key1', suffixes=('_left', '_right'))key1key2_leftlvalkey2_rightrval0fooone1one41fooone1one52footwo2one43footwo2one54barone3one65barone3two7
merge的参数请参见下表：
indicator添加特殊的列merge，它可以指明每个行的来源，它的值有left_only、right_only或both，根据每行的合并数据的来源。
索引上的合并
有时候，DataFrame中的连接键位于其索引中。在这种情况下，你可以传入left_index=True或right_index=True（或两个都传）以说明索引应该被用作连接键：
left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],'value': range(6)})right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])left1keyvalue0a01b12a23a34b45c5right1group_vala3.5b7.0
pd.merge(left1, right1, left_on='key', right_index=True)keyvaluegroup_val0a03.52a23.53a33.51b17.04b47.0
由于默认的merge方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：
pd.merge(left1, right1, left_on='key', right_index=True, how='outer')keyvaluegroup_val0a03.52a23.53a33.51b17.04b47.05c5NaN
对于层次化索引的数据，事情就有点复杂了，因为索引的合并默认是多键合并：
lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio','Nevada', 'Nevada'],'key2': [2000, 2001, 2002, 2001, 2002],'data': np.arange(5.)})righth = pd.DataFrame(np.arange(12).reshape((6, 2)),index=[['Nevada', 'Nevada', 'Ohio', 'Ohio','Ohio', 'Ohio'],[2001, 2000, 2000, 2000, 2001, 2002]],columns=['event1', 'event2'])
lefthdatakey1key200.0Ohio200011.0Ohio200122.0Ohio200233.0Nevada200144.0Nevada2002righthevent1event2Nevada200101200023Ohio20004520006720018920021011
这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用how='outer'对重复索引值的处理）：
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)datakey1key2event1event200.0Ohio20004500.0Ohio20006711.0Ohio20018922.0Ohio2002101133.0Nevada200101
同时使用合并双方的索引也没问题：
left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],index=['a', 'c', 'e'],columns=['Ohio', 'Nevada'])right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],index=['b', 'c', 'd', 'e'],columns=['Missouri', 'Alabama'])left2OhioNevadaa1.02.0c3.04.0e5.06.0right2MissouriAlabamab7.08.0c9.010.0d11.012.0e13.014.0
pd.merge(left2, right2, how='outer', left_index=True, right_index=True)OhioNevadaMissouriAlabamaa1.02.0NaNNaNbNaNNaN7.08.0c3.04.09.010.0dNaNNaN11.012.0e5.06.013.014.0
DataFrame还有一个便捷的join实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：
left2.join(right2, how='outer')OhioNevadaMissouriAlabamaa1.02.0NaNNaNbNaNNaN7.08.0c3.04.09.010.0dNaNNaN11.012.0e5.06.013.014.0
因为一些历史版本的遗留原因，DataFrame的join方法默认使用的是左连接，保留左边表的行索引。它还支持在调用的DataFrame的列上，连接传递的DataFrame索引：
left1keyvalue0a01b12a23a34b45c5right1group_vala3.5b7.0
left1.join(right1, on='key')keyvaluegroup_val0a03.51b17.02a23.53a33.54b47.05c5NaN
最后，对于简单的索引合并，你还可以向join传入一组DataFrame，下一节会介绍更为通用的concat函数，也能实现此功能：
another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],index=['a', 'c', 'e', 'f'],columns=['New York','Oregon'])anotherNew YorkOregona7.08.0c9.010.0e11.012.0f16.017.0
right2MissouriAlabamab7.08.0c9.010.0d11.012.0e13.014.0left2OhioNevadaa1.02.0c3.04.0e5.06.0
left2.join([right2, another])OhioNevadaMissouriAlabamaNew YorkOregona1.02.0NaNNaN7.08.0c3.04.09.010.09.010.0e5.06.013.014.011.012.0
left2.join([right2, another], how='outer')OhioNevadaMissouriAlabamaNew YorkOregona1.02.0NaNNaN7.08.0bNaNNaN7.08.0NaNNaNc3.04.09.010.09.010.0dNaNNaN11.012.0NaNNaNe5.06.013.014.011.012.0fNaNNaNNaNNaN16.017.0
轴向连接
另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy的concatenation函数可以用NumPy数组来做：
arr = np.arange(12).reshape((3,4))arrarray([[ 0, 1, 2, 3],[ 4, 5, 6, 7],[ 8, 9, 10, 11]])np.concatenate([arr, arr], axis=1)array([[ 0, 1, 2, 3, 0, 1, 2, 3],[ 4, 5, 6, 7, 4, 5, 6, 7],[ 8, 9, 10, 11, 8, 9, 10, 11]])
对于pandas对象（如Series和DataFrame），带有标签的轴使你能够进一步推广数组的连接运算。具体点说，你还需要考虑以下这些东西：
如果对象在其它轴上的索引不同，我们应该合并这些轴的不同元素还是只使用交集？连接的数据集是否需要在结果对象中可识别？连接轴中保存的数据是否需要保留？许多情况下，DataFrame默认的整数标签最好在连接时删掉。
pandas的concat函数提供了一种能够解决这些问题的可靠方式。这里将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的Series：
s1 = pd.Series([0,1], index=['a', 'b'])s2 = pd.Series([2,3,4], index=['c','d','e'])s3 = pd.Series([5,6], index=['f','g'])
对这些对象调用concat可以将值和索引粘合在一起：
pd.concat([s1, s2, s3])a 0b 1c 2d 3e 4f 5g 6dtype: int64
默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame（axis=1是列）：
pd.concat([s1,s2,s3], axis=1)012a0.0NaNNaNb1.0NaNNaNcNaN2.0NaNdNaN3.0NaNeNaN4.0NaNfNaNNaN5.0gNaNNaN6.0
这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入join='inner'即可得到它们的交集：
s4 = pd.concat([s1, s3])s4a 0b 1f 5g 6dtype: int64pd.concat([s1, s4], axis=1)01a0.00b1.01fNaN5gNaN6pd.concat([s1, s4], axis=1,join='inner')01a00b11
在这个例子中，f和g标签消失了，是因为使用的是join='inner’选项。
你可以通过join_axes指定要在其它轴上使用的索引：
pd.concat([s1, s4], axis=1, join_axes=[['a','c','b', 'e']])01a0.00.0cNaNNaNb1.01.0eNaNNaN
不过有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的：
result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])resultone a 0b 1two a 0b 1three f 5g 6dtype: int64result.unstack()abfgone0.01.0NaNNaNtwo0.01.0NaNNaNthreeNaNNaN5.06.0
