在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。
首先，我会介绍pandas的层次化索引，它广泛用于以上操作。然后，我深入介绍了一些特殊的数据操作。在第14章，你可以看到这些工具的多种应用。
层次化索引
层次化索引(hierarchical indexing)是pandas的一项重要功能，它使你能在一个轴上拥有多个(两个以上)索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：
import pandas as pd
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]])
data
a 1 -1.631597
2 0.565528
3 1.349319
b 1 -0.364927
3 -0.069814
c 1 0.866054
2 -0.007507
d 2 -1.166422
3 -1.620899
dtype: float64
看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”：
data.index
MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],
labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])
对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：
data['b']
1 -0.364927
3 -0.069814
dtype: float64
data['b':'c']
b 1 -0.364927
3 -0.069814
c 1 0.866054
2 -0.007507
dtype: float64
data.loc[['b', 'd']]
b 1 -0.364927
3 -0.069814
d 2 -1.166422
3 -1.620899
dtype: float64
有时甚至还可以在“内层”中进行选取
data.loc["a",2]
0.5655279622354669
data.loc[:, 2]
a 0.565528
c -0.007507
d -1.166422
dtype: float64
层次化索引在数据重塑和基于分组的操作(如透视表生成)中扮演着重要的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：
data.unstack()
123
a
-1.631597
0.565528
1.349319
b
-0.364927
NaN
-0.069814
c
0.866054
-0.007507
NaN
d
NaN
-1.166422
-1.620899
unstack的逆运算是stack：
data.unstack().stack()
a 1 -1.631597
2 0.565528
3 1.349319
b 1 -0.364927
3 -0.069814
c 1 0.866054
2 -0.007507
d 2 -1.166422
3 -1.620899
dtype: float64
stack和unstack将在本章后面详细讲解。
对于一个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']])
frame
OhioColorado
GreenRedGreen
a1
0
1
2
2
3
4
5
b1
6
7
8
2
9
10
11
各层都可以有名字(可以是字符串，也可以是别的Python对象)。如果指定了名称，它们就会显示在控制台输出中：
frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']
frame
stateOhioColorado
colorGreenRedGreen
key1key2
a1
0
1
2
2
3
4
5
b1
6
7
8
2
9
10
11
注意：小心区分索引名state、color与行标签。
有了部分列索引，因此可以轻松选取列分组
frame['Ohio']
colorGreenRed
key1key2
a1
0
1
2
3
4
b1
6
7
2
9
10
可以单独创建MultiIndex然后复用。上面那个DataFrame中的(带有分级名称)列可以这样创建：
m_index1 = pd.MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
names=['state', 'color'])
m_index1
MultiIndex(levels=[['Colorado', 'Ohio'], ['Green', 'Red']],
labels=[[1, 1, 0], [0, 1, 0]],
names=['state', 'color'])
df1=pd.DataFrame(np.arange(12).reshape(4,3),columns=m_index1)
df1
stateOhioColorado
colorGreenRedGreen
0
0
1
2
1
3
4
5
2
6
7
8
3
9
10
11
重排与分级排序
有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象(但数据不会发生变化)：
frame
stateOhioColorado
colorGreenRedGreen
key1key2
a1
0
1
2
2
3
4
5
b1
6
7
8
2
9
10
11
frame.swaplevel('key1', 'key2')
stateOhioColorado
colorGreenRedGreen
key2key1
1a
0
1
2
2a
3
4
5
1b
6
7
8
2b
9
10
11
而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：
frame.sort_index(level=1)
stateOhioColorado
colorGreenRedGreen
key1key2
a1
0
1
2
b1
6
7
8
a2
3
4
5
b2
9
10
11
frame.swaplevel(0, 1).sort_index(level=0)
stateOhioColorado
colorGreenRedGreen
key2key1
1a
0
1
2
b
6
7
8
2a
3
4
5
b
9
10
11
根据级别汇总统计
许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例，我们可以根据行或列上的级别来进行求和：
frame.sum(level='key2')
stateOhioColorado
colorGreenRedGreen
key2
1
6
8
10
2
12
14
16
frame.sum(level='color', axis=1)
colorGreenRed
key1key2
a1
2
1
2
8
4
b1
14
7
2
20
10
这其实是利用了pandas的groupby功能，本书稍后将对其进行详细讲解。
使用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]})
frame
abcd
0
0
7
one
0
1
1
6
one
1
2
2
5
one
2
3
3
4
two
0
4
4
3
two
1
5
5
2
two
2
6
6
1
two
3
DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：
frame2 = frame.set_index(['c', 'd'])
frame2
ab
cd
one0
0
7
1
1
6
2
2
5
two0
3
4
1
4
3
2
5
2
3
6
1
默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来：
frame.set_index(['c', 'd'], drop=False)
abcd
cd
one0
0
7
one
0
1
1
6
one
1
2
2
5
one
2
two0
3
4
two
0
1
4
3
two
1
2
5
2
two
2
3
6
1
two
3
reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列里面：
frame2.reset_index()
cdab
0
one
0
0
7
1
one
1
1
6
2
one
2
2
5
3
two
0
3
4
4
two
1
4
3
5
two
2
5
2
6
two
3
6
1
合并数据集
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)})
df1
keydata1
0
b
0
1
b
1
2
a
2
3
c
3
4
a
4
5
a
5
6
b
6
df2
keydata2
0
a
0
1
b
1
2
d
2
这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到
pd.merge(df1, df2)
keydata1data2
0
b
0
1
1
b
1
1
2
b
6
1
3
a
2
0
4
a
4
0
5
a
5
0
注意，我并没有指明要用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当做键。不过，最好明确指定一下：
pd.merge(df1, df2, on='key')
keydata1data2
0
b
0
1
1
b
1
1
2
b
6
1
3
a
2
0
4
a
4
0
5
a
5
0
如果两个对象的列名不同，也可以分别进行指定：
df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
'data1': range(7)})
df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],
'data2': range(3)})
pd.merge(df3, df4, left_on='lkey', right_on='rkey')
lkeydata1rkeydata2
0
b
0
b
1
1
b
1
b
1
2
b
6
b
1
3
a
2
a
0
4
a
4
a
0
5
a
5
a
0
可能你已经注意到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“内连接”；结果中的键是交集。其他方式还有"left"、“right"以及"outer”。外连接求取的是键的并集，组合了左连接和右连接的效果：
pd.merge(df1, df2, how='outer')
keydata1data2
0
b
0.0
1.0
1
b
1.0
1.0
2
b
6.0
1.0
3
a
2.0
0.0
4
a
4.0
0.0
5
a
5.0
0.0
6
c
3.0
NaN
7
d
NaN
2.0
这些选项进行了总结。
选项说明
inner
使用两个表都有的键
left
使用左表中所有的键
right
使用右表中所有的键
outer
使用两个表中所有的键
多对多的合并有些不直观。看下面的例子：
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)})
df1
keydata1
0
b
0
1
b
1
2
a
2
3
c
3
4
a
4
5
b
5
df2
keydata2
0
a
0
1
b
1
2
a
2
3
b
3
4
d
4
pd.merge(df1, df2, on='key', how='left')
keydata1data2
0
b
0
1.0
1
b
0
3.0
2
b
1
1.0
3
b
1
3.0
4
a
2
0.0
5
a
2
2.0
6
c
3
NaN
7
a
4
0.0
8
a
4
2.0
9
b
5
1.0
10
b
5
3.0
多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最终结果中就有6个"b"行。连接方式只影响出现在结果中的不同的键的值：
pd.merge(df1, df2, how='inner')
keydata1data2
0
b
0
1
1
b
0
3
2
b
1
1
3
b
1
3
4
b
5
1
5
b
5
3
6
a
2
0
7
a
2
2
8
a
4
0
9
a
4
2
要根据多个键进行合并，传入一个由列名组成的列表即可
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]})
left
key1key2lval
0
foo
one
1
1
foo
two
2
2
bar
one
3
right
key1key2rval
0
foo
one
4
1
foo
one
5
2
bar
one
6
3
bar
two
7
pd.merge(left, right, on=['key1', 'key2'], how='outer')
key1key2lvalrval
0
foo
one
1.0
4.0
1
foo
one
1.0
5.0
2
foo
two
2.0
NaN
3
bar
one
3.0
6.0
4
bar
two
NaN
7.0
结果中会出现哪些键组合取决于所选的合并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个连接键(当然，实际上并不是这么回事)。
注意：在进行列－列连接时，DataFrame对象中的索引会被丢弃。
对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题(查看前面介绍的重命名轴标签)，但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
pd.merge(left, right, on='key1')
key1key2_xlvalkey2_yrval
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
pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
key1key2_leftlvalkey2_rightrval
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
merge的参数请参见表。使用DataFrame的行索引合并是下一节的主题。
参数说明
left
参与合并的左侧DataFrame
right
参与合并的右侧DataFrame
how
“inner”,“outer”.“left”,“right"其中之一，默认"inner”
on
用于连接的列名。必须存在于左右两个DataFrame对象中。如果未指定，则以left和right列名的交集作为连接键
left_on
左侧DtatFrame中用作连接键的列
right_on
右侧DtatFrame中用作连接键的列
left_index
左侧的行索引用作其连接键
right_index
类似于left_index
sort
根据连接键对合并后的数据进行排序，默认True，有时在处理大数集时，禁用该选项可获得更好的性能
suffixes
字符串值元组，用于追加到重叠列名的末尾
copy
设置为False，可以在某些特殊情况下避免将数据复制到结果数组中。默认总是复制
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'])
left1
keyvalue
0
a
0
1
b
1
2
a
2
3
a
3
4
b
4
5
c
5
right1
group_val
a
3.5
b
7.0
pd.merge(left1, right1, left_on='key', right_index=True)
keyvaluegroup_val
0
a
0
3.5
2
a
2
3.5
3
a
3
3.5
1
b
1
7.0
4
b
4
7.0
由于默认的merge方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：
pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
keyvaluegroup_val
0
a
0
3.5
2
a
2
3.5
3
a
3
3.5
1
b
1
7.0
4
b
4
7.0
5
c
5
NaN
对于层次化索引的数据，事情就有点复杂了，因为索引的合并默认是多键合并：
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'])
lefth
key1key2data
0
Ohio
2000
0.0
1
Ohio
2001
1.0
2
Ohio
2002
2.0
3
Nevada
2001
3.0
4
Nevada
2002
4.0
righth
event1event2
Nevada2001
0
1
2000
2
3
Ohio2000
4
5
2000
6
7
2001
8
9
2002
10
11
这种情况下，你必须以列表的形式指明用作合并键的多个列(注意用how='outer’对重复索引值的处理)：
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
key1key2dataevent1event2
0
Ohio
2000
0.0
4
5
0
Ohio
2000
0.0
6
7
1
Ohio
2001
1.0
8
9
2
Ohio
2002
2.0
10
11
3
Nevada
2001
3.0
0
1
pd.merge(lefth, righth, left_on=['key1', 'key2'],
right_index=True, how='outer')
key1key2dataevent1event2
0
Ohio
2000
0.0
4.0
5.0
0
Ohio
2000
0.0
6.0
7.0
1
Ohio
2001
1.0
8.0
9.0
2
Ohio
2002
2.0
10.0
11.0
3
Nevada
2001
3.0
0.0
1.0
4
Nevada
2002
4.0
NaN
NaN
4
Nevada
2000
NaN
2.0
3.0
同时使用合并双方的索引也没问题：
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'])
left2
OhioNevada
a
1.0
2.0
c
3.0
4.0
e
5.0
6.0
right2
MissouriAlabama
b
7.0
8.0
c
9.0
10.0
d
11.0
12.0
e
13.0
14.0
pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
OhioNevadaMissouriAlabama
a
1.0
2.0
NaN
NaN
b
NaN
NaN
7.0
8.0
c
3.0
4.0
9.0
10.0
d
NaN
NaN
11.0
12.0
e
5.0
6.0
13.0
14.0
DataFrame还有一个便捷的join实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：
left2.join(right2, how='outer')
OhioNevadaMissouriAlabama
a
1.0
2.0
NaN
NaN
b
NaN
NaN
7.0
8.0
c
3.0
4.0
9.0
10.0
d
NaN
NaN
11.0
12.0
e
5.0
6.0
13.0
14.0
因为一些历史版本的遗留原因，DataFrame的join方法默认使用的是左连接，保留左边表的行索引。它还支持在调用的DataFrame的列上，连接传递的DataFrame索引：
left1.join(right1, on='key')
keyvaluegroup_val
0
a
0
3.5
1
b
1
7.0
2
a
2
3.5
3
a
3
3.5
4
b
4
7.0
5
c
5
NaN
最后，对于简单的索引合并，你还可以向join传入一组DataFrame，下一节会介绍更为通用的concat函数，也能实现此功能：
another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
index=['a', 'c', 'e', 'f'],
columns=['New York',
'Oregon'])
another
New YorkOregon
a
7.0
8.0
c
9.0
10.0
e
11.0
12.0
f
16.0
17.0
left2.join([right2, another])
OhioNevadaMissouriAlabamaNew YorkOregon
a
1.0
2.0
NaN
NaN
7.0
8.0
c
3.0
4.0
9.0
10.0
9.0
10.0
e
5.0
6.0
13.0
14.0
11.0
12.0
left2.join([right2, another], how='outer')
/root/miniconda3/lib/python3.6/site-packages/pandas/core/frame.py:6369: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
verify_integrity=True)
OhioNevadaMissouriAlabamaNew YorkOregon
a
1.0
2.0
NaN
NaN
7.0
8.0
b
NaN
NaN
7.0
8.0
NaN
NaN
c
3.0
4.0
9.0
10.0
9.0
10.0
d
NaN
NaN
11.0
12.0
NaN
NaN
e
5.0
6.0
13.0
14.0
11.0
12.0
f
NaN
NaN
NaN
NaN
16.0
17.0
轴向连接
另一种数据合并运算也被称作连接(concatenation)、绑定(binding)或堆叠(stacking)。NumPy的concatenation函数可以用NumPy数组来做：
arr = np.arange(12).reshape((3, 4))
arr
array([[ 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 0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64
默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame(axis=1是列)：
pd.concat([s1, s2, s3], axis=1)
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
"""Entry point for launching an IPython kernel.
012
a
0.0
NaN
NaN
b
1.0
NaN
NaN
c
NaN
2.0
NaN
d
NaN
3.0
NaN
e
NaN
4.0
NaN
f
NaN
NaN
5.0
g
NaN
NaN
6.0
这种情况下，另外的轴上没有重叠，从索引的有序并集(外连接)上就可以看出来。传入join='inner’即可得到它们的交集：
s4 = pd.concat([s1, s3])
s4
a 0
b 1
f 5
g 6
dtype: int64
pd.concat([s1, s4], axis=1)
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
"""Entry point for launching an IPython kernel.
01
a
0.0
0
b
1.0
1
f
NaN
5
g
NaN
6
pd.concat([s1, s4], axis=1, join='inner')
01
a
0
0
b
1
1
在这个例子中，f和g标签消失了，是因为使用的是join='inner’选项。
你可以通过join_axes指定要在其它轴上使用的索引：
pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])
01
a
0.0
0.0
c
NaN
NaN
b
1.0
1.0
e
NaN
NaN
不过有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的：
result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
result
one a 0
b 1
two a 0
b 1
three f 5
g 6
dtype: int64
result.unstack()
abfg
one
0.0
1.0
NaN
NaN
two
0.0
1.0
NaN
NaN
three
NaN
NaN
5.0
6.0
如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头：
pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
"""Entry point for launching an IPython kernel.
onetwothree
a
0.0
NaN
NaN
b
1.0
NaN
NaN
c
NaN
2.0
NaN
d
NaN
3.0
NaN
e
NaN
4.0
NaN
f
NaN
NaN
5.0
g
NaN
NaN
6.0
同样的逻辑也适用于DataFrame对象：
df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
columns=['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
columns=['three', 'four'])
df1
onetwo
a
0
1
b
2
3
c
4
5
df2
threefour
a
5
6
c
7
8
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
"""Entry point for launching an IPython kernel.
level1level2
onetwothreefour
a
0
1
5.0
6.0
b
2
3
NaN
NaN
c
4
5
7.0
8.0
如果传入的不是列表而是一个字典，则字典的键就会被当做keys选项的值：
pd.concat({'level1': df1, 'level2': df2}, axis=1)
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
"""Entry point for launching an IPython kernel.
level1level2
onetwothreefour
a
0
1
5.0
6.0
b
2
3
NaN
NaN
c
4
5
7.0
8.0
此外还有两个用于管理层次化索引创建方式的参数(参见表)。举个例子，我们可以用names参数命名创建的轴级别：
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],
names=['upper', 'lower'])
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:2: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.
upperlevel1level2
loweronetwothreefour
a
0
1
5.0
6.0
b
2
3
NaN
NaN
c
4
5
7.0
8.0
最后一个关于DataFrame的问题是，DataFrame的行索引不包含任何相关数据：
df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
df1
abcd
0
0.177684
-0.333667
0.845828
2.385357
1
-1.223687
1.056661
0.900190
0.144737
2
0.004082
0.694430
-0.314125
2.032626
df2
bda
0
1.083106
1.116694
-0.413869
1
-0.671038
0.892496
0.414917
在这种情况下，传入ignore_index=True即可：
pd.concat([df1, df2], ignore_index=True, sort=False)
abcd
0
0.177684
-0.333667
0.845828
2.385357
1
-1.223687
1.056661
0.900190
0.144737
2
0.004082
0.694430
-0.314125
2.032626
3
-0.413869
1.083106
NaN
1.116694
4
0.414917
-0.671038
NaN
0.892496
concat函数的参数
参数说明
objs
参与连接的pandas对象的列表或字典。唯一必需的参数
axis
指明连接的轴向，默认0
join
inner，outer其中之一，默认是outer。指明其他轴上的索引是按交集(inner)还是并集(outer)进行合并
join_axes
指明用于其他n-1条轴的索引，不执行并集/交集运算
keys
与连接对象有关的值，用于形成连接轴上的层次化索引
levels
指定用作层次化索引各级别上的索引，如果设置了keys的话
names
用于创建分层级别的名称，如果设置了keys或(和)levels的话
verify_intergrity
检查结果对象新轴上的重复情况，默认False允许重复
ignore_index
不保留连接轴上的索引，产生一组新索引range(total_length)
合并重叠数据
还有一种数据组合问题不能用简单的合并(merge)或连接(concatenation)运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子，我们使用NumPy的where函数，它表示一种等价于面向数组的if-else：
a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
index=['f', 'e', 'd', 'c', 'b', 'a'])
b = pd.Series(np.arange(len(a), dtype=np.float64),
index=['f', 'e', 'd', 'c', 'b', 'a'])
b[-1] = np.nan
a
f NaN
e 2.5
d NaN
c 3.5
b 4.5
a NaN
dtype: float64
b
f 0.0
e 1.0
d 2.0
c 3.0
b 4.0
a NaN
dtype: float64
np.where(pd.isnull(a), b, a)
array([0. , 2.5, 2. , 3.5, 4.5, nan])
Series有一个combine_first方法，实现的也是一样的功能，还带有pandas的数据对齐：
b[:-2].combine_first(a[2:])
a NaN
b 4.5
c 3.0
d 2.0
e 1.0
f 0.0
dtype: float64
对于DataFrame，combine_first自然也会在列上做同样的事情，因此你可以将其看做：用传递对象中的数据为调用对象的缺失数据“打补丁”：
df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],
'b': [np.nan, 2., np.nan, 6.],
'c': range(2, 18, 4)})
df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.],
'b': [np.nan, 3., 4., 6., 8.]})
df1
abc
0
1.0
NaN
2
1
NaN
2.0
6
2
5.0
NaN
10
3
NaN
6.0
14
df2
ab
0
5.0
NaN
1
4.0
3.0
2
NaN
4.0
3
3.0
6.0
4
7.0
8.0
df1.combine_first(df2)
abc
0
1.0
NaN
2.0
1
4.0
2.0
6.0
2
5.0
4.0
10.0
3
3.0
6.0
14.0
4
7.0
8.0
NaN
重塑和轴向旋转
有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑(reshape)或轴向旋转(pivot)运算。
重塑层次化索引
层次化索引为DataFrame数据的重排任务提供了一种具有良好一致性的方式。主要功能有二：
stack：将数据的列“旋转”为行。
unstack：将数据的行“旋转”为列。
我将通过一系列的范例来讲解这些操作。接下来看一个简单的DataFrame，其中的行列索引均为字符串数组：
data = pd.DataFrame(np.arange(6).reshape((2, 3)),
index=pd.Index(['Ohio','Colorado'], name='state'),
columns=pd.Index(['one', 'two', 'three'],name='number'))
data
numberonetwothree
state
Ohio
0
1
2
Colorado
3
4
5
对该数据使用stack方法即可将列转换为行，得到一个Series：
result = data.stack()
result
state number
Ohio one 0
two 1
three 2
Colorado one 3
two 4
three 5
dtype: int64
对于一个层次化索引的Series，你可以用unstack将其重排为一个DataFrame：
result.unstack()
numberonetwothree
state
Ohio
0
1
2
Colorado
3
4
5
默认情况下，unstack操作的是最内层(stack也是如此)。传入分层级别的编号或名称即可对其它级别进行unstack操作
result.unstack(0)
stateOhioColorado
number
one
0
3
two
1
4
three
2
5
result.unstack('state')
stateOhioColorado
number
one
0
3
two
1
4
three
2
5
如果不是所有的级别值都能在各分组中找到的话，则unstack操作可能会引入缺失数据：
s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
data2 = pd.concat([s1, s2], keys=['one', 'two'])
data2
one a 0
b 1
c 2
d 3
two c 4
d 5
e 6
dtype: int64
data2.unstack()
abcde
one
0.0
1.0
2.0
3.0
NaN
two
NaN
NaN
4.0
5.0
6.0
stack默认会滤除缺失数据，因此该运算是可逆的：
data2.unstack()
abcde
one
0.0
1.0
2.0
3.0
NaN
two
NaN
NaN
4.0
5.0
6.0
data2.unstack().stack()
one a 0.0
b 1.0
c 2.0
d 3.0
two c 4.0
d 5.0
e 6.0
dtype: float64
data2.unstack().stack(dropna=False)
one a 0.0
b 1.0
c 2.0
d 3.0
e NaN
two a NaN
b NaN
c 4.0
d 5.0
e 6.0
dtype: float64
在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别：
df = pd.DataFrame({'left': result, 'right': result + 5},
columns=pd.Index(['left', 'right'], name='side'))
df
sideleftright
statenumber
Ohioone
0
5
two
1
6
three
2
7
Coloradoone
3
8
two
4
9
three
5
10
df.unstack('state')
sideleftright
stateOhioColoradoOhioColorado
number
one
0
3
5
8
two
1
4
6
9
three
2
5
7
10
当调用stack，我们可以指明轴的名字：
df.unstack('state').stack('side')
stateColoradoOhio
numberside
oneleft
3
0
right
8
5
twoleft
4
1
right
9
6
threeleft
5
2
right
10
7
将“长格式”旋转为“宽格式”
多个时间序列数据通常是以所谓的“长格式”(long)或“堆叠格式”(stacked)存储在数据库和CSV中的。我们先加载一些示例数据，做一些时间序列规整和数据清洗：
data = pd.read_csv('examples/macrodata.csv')
data.head()
yearquarterrealgdprealconsrealinvrealgovtrealdpicpim1tbilrateunemppopinflrealint
0
1959.0
1.0
2710.349
1707.4
286.898
470.045
1886.9
28.98
139.7
2.82
5.8
177.146
0.00
0.00
1
1959.0
2.0
2778.801
1733.7
310.859
481.301
1919.7
29.15
141.7
3.08
5.1
177.830
2.34
0.74
2
1959.0
3.0
2775.488
1751.8
289.226
491.260
1916.4
29.35
140.5
3.82
5.3
178.657
2.74
1.09
3
1959.0
4.0
2785.204
1753.7
299.356
484.052
1931.3
29.37
140.0
4.33
5.6
179.386
0.27
4.06
4
1960.0
1.0
2847.699
1770.5
331.722
462.199
1955.5
29.54
139.6
3.50
5.2
180.007
2.31
1.19
periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,
name='date')
periods
PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2',
'1960Q3', '1960Q4', '1961Q1', '1961Q2',
...
'2007Q2', '2007Q3', '2007Q4', '2008Q1', '2008Q2', '2008Q3',
'2008Q4', '2009Q1', '2009Q2', '2009Q3'],
dtype='period[Q-DEC]', name='date', length=203, freq='Q-DEC')
columns = pd.Index(['realgdp', 'infl', 'unemp'], name='item')
columns
Index(['realgdp', 'infl', 'unemp'], dtype='object', name='item')
data = data.reindex(columns=columns)
data.head()
itemrealgdpinflunemp
0
2710.349
0.00
5.8
1
2778.801
2.34
5.1
2
2775.488
2.74
5.3
3
2785.204
0.27
5.6
4
2847.699
2.31
5.2
data.index = periods.to_timestamp('D', 'end')
data.head()
itemrealgdpinflunemp
date
1959-03-31
2710.349
0.00
5.8
1959-06-30
2778.801
2.34
5.1
1959-09-30
2775.488
2.74
5.3
1959-12-31
2785.204
0.27
5.6
1960-03-31
2847.699
2.31
5.2
ldata = data.stack().reset_index().rename(columns={0: 'value'})
ldata.head()
dateitemvalue
0
1959-03-31
realgdp
2710.349
1
1959-03-31
infl
0.000
2
1959-03-31
unemp
5.800
3
1959-06-30
realgdp
2778.801
4
1959-06-30
infl
2.340
这就是多个时间序列(或者其它带有两个或多个键的可观察数据，这里，我们的键是date和item)的长格式。表中的每行代表一次观察。
关系型数据库(如MySQL)中的数据经常都是这样存储的，因为固定架构(即列名和数据类型)有一个好处：随着表中数据的添加，item列中的值的种类能够增加。在前面的例子中，date和item通常就是主键(用关系型数据库的说法)，不仅提供了关系完整性，而且提供了更为简单的查询支持。有的情况下，使用这样的数据会很麻烦，你可能会更喜欢DataFrame，不同的item值分别形成一列，date列中的时间戳则用作索引。DataFrame的pivot方法完全可以实现这个转换：
pivoted = ldata.pivot('date', 'item', 'value')
pivoted.head()
iteminflrealgdpunemp
date
1959-03-31
0.00
2710.349
5.8
1959-06-30
2.34
2778.801
5.1
1959-09-30
2.74
2775.488
5.3
1959-12-31
0.27
2785.204
5.6
1960-03-31
2.31
2847.699
5.2
前两个传递的值分别用作行和列索引，最后一个可选值则是用于填充DataFrame的数据列。假设有两个需要同时重塑的数据列：
ldata['value2'] = np.random.randn(len(ldata))
ldata.head()
dateitemvaluevalue2
0
1959-03-31
realgdp
2710.349
-0.201684
1
1959-03-31
infl
0.000
-0.821067
2
1959-03-31
unemp
5.800
-0.520952
3
1959-06-30
realgdp
2778.801
1.085979
4
1959-06-30
infl
2.340
0.879421
如果忽略最后一个参数，得到的DataFrame就会带有层次化的列：
pivoted = ldata.pivot('date', 'item')
pivoted[:5]
valuevalue2
iteminflrealgdpunempinflrealgdpunemp
date
1959-03-31
0.00
2710.349
5.8
-0.821067
-0.201684
-0.520952
1959-06-30
2.34
2778.801
5.1
0.879421
1.085979
-0.013487
1959-09-30
2.74
2775.488
5.3
1.103906
0.496249
0.645224
1959-12-31
0.27
2785.204
5.6
-1.825783
-0.190713
1.630975
1960-03-31
2.31
2847.699
5.2
-0.625469
0.529104
-1.600850
pivoted['value'][:5]
iteminflrealgdpunemp
date
1959-03-31
0.00
2710.349
5.8
1959-06-30
2.34
2778.801
5.1
1959-09-30
2.74
2775.488
5.3
1959-12-31
0.27
2785.204
5.6
1960-03-31
2.31
2847.699
5.2
注意，pivot其实就是用set_index创建层次化索引，再用unstack重塑：
ldata.set_index(['date', 'item']).head()
valuevalue2
dateitem
1959-03-31realgdp
2710.349
-0.201684
infl
0.000
-0.821067
unemp
5.800
-0.520952
1959-06-30realgdp
2778.801
1.085979
infl
2.340
0.879421
unstacked = ldata.set_index(['date', 'item']).unstack('item')
unstacked[:7]
valuevalue2
iteminflrealgdpunempinflrealgdpunemp
date
1959-03-31
0.00
2710.349
5.8
-0.821067
-0.201684
-0.520952
1959-06-30
2.34
2778.801
5.1
0.879421
1.085979
-0.013487
1959-09-30
2.74
2775.488
5.3
1.103906
0.496249
0.645224
1959-12-31
0.27
2785.204
5.6
-1.825783
-0.190713
1.630975
1960-03-31
2.31
2847.699
5.2
-0.625469
0.529104
-1.600850
1960-06-30
0.14
2834.390
5.2
-1.478618
-1.189062
0.675593
1960-09-30
2.70
2839.022
5.6
-0.659115
-0.061352
0.118526
将“宽格式”旋转为“长格式”
旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame，而是合并多个列成为一个，产生一个比输入长的DataFrame。看一个例子：
df = pd.DataFrame({'key': ['foo', 'bar', 'baz'],
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]})
df
keyABC
0
foo
1
4
7
1
bar
2
5
8
2
baz
3
6
9
key列可能是分组指标，其它的列是数据值。当使用pandas.melt，我们必须指明哪些列是分组指标。下面使用key作为唯一的分组指标：
melted = pd.melt(df, ['key'])
melted
keyvariablevalue
0
foo
A
1
1
bar
A
2
2
baz
A
3
3
foo
B
4
4
bar
B
5
5
baz
B
6
6
foo
C
7
7
bar
C
8
8
baz
C
9
使用pivot，可以重塑回原来的样子：
reshaped = melted.pivot('key', 'variable', 'value')
reshaped
variableABC
key
bar
2
5
8
baz
3
6
9
foo
1
4
7
因为pivot的结果从列创建了一个索引，用作行标签，我们可以使用reset_index将数据移回列：
reshaped.reset_index()
variablekeyABC
0
bar
2
5
8
1
baz
3
6
9
2
foo
1
4
7
你还可以指定列的子集，作为值的列：
pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])
keyvariablevalue
0
foo
A
1
1
bar
A
2
2
baz
A
3
3
foo
B
4
4
bar
B
5
5
baz
B
6
pandas.melt也可以不用分组指标：
pd.melt(df, value_vars=['A', 'B', 'C'])
variablevalue
0
A
1
1
A
2
2
A
3
3
B
4
4
B
5
5
B
6
6
C
7
7
C
8
8
C
9
pd.melt(df, value_vars=['key', 'A', 'B'])
variablevalue
0
key
foo
1
key
bar
2
key
baz
3
A
1
4
A
2
5
A
3
6
B
4
7
B
5
8
B
6
总结
现在你已经掌握了pandas数据导入、清洗、重塑，我们可以进一步学习matplotlib数据可视化。我们在稍后会回到pandas，学习更高级的分析。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
