pandas数据规整：聚合、合并和重塑

在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。
首先，我会介绍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()

 

	1	2	3
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

 

		Ohio		Colorado
		Green	Red	Green
a	1	0	1	2
	2	3	4	5
b	1	6	7	8
	2	9	10	11

各层都可以有名字（可以是字符串，也可以是别的Python对象）。如果指定了名称，它们就会显示在控制台输出中：

frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']

frame

 

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
	2	3	4	5
b	1	6	7	8
	2	9	10	11

注意：小心区分索引名state、color与行标签。

有了部分列索引，因此可以轻松选取列分组

frame['Ohio']

 

	color	Green	Red
key1	key2
a	1	0	1
	2	3	4
b	1	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

 

state	Ohio		Colorado
color	Green	Red	Green
0	0	1	2
1	3	4	5
2	6	7	8
3	9	10	11

重排与分级排序

有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：

frame

 

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
	2	3	4	5
b	1	6	7	8
	2	9	10	11

frame.swaplevel('key1', 'key2')

 

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
2	a	3	4	5
1	b	6	7	8
2	b	9	10	11

而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：

frame.sort_index(level=1)

 

	state	Ohio		Colorado
	color	Green	Red	Green
key1	key2
a	1	0	1	2
b	1	6	7	8
a	2	3	4	5
b	2	9	10	11

frame.swaplevel(0, 1).sort_index(level=0)

 

	state	Ohio		Colorado
	color	Green	Red	Green
key2	key1
1	a	0	1	2
	b	6	7	8
2	a	3	4	5
	b	9	10	11

根据级别汇总统计

许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例，我们可以根据行或列上的级别来进行求和：

frame.sum(level='key2')

 

state	Ohio		Colorado
color	Green	Red	Green
key2
1	6	8	10
2	12	14	16

frame.sum(level='color', axis=1)

 

	color	Green	Red
key1	key2
a	1	2	1
	2	8	4
b	1	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   

 

	a	b	c	d
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

 

		a	b
c	d
one	0	0	7
	1	1	6
	2	2	5
two	0	3	4
	1	4	3
	2	5	2
	3	6	1

默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来：

frame.set_index(['c', 'd'], drop=False)

 

		a	b	c	d
c	d
one	0	0	7	one	0
	1	1	6	one	1
	2	2	5	one	2
two	0	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()

 

	c	d	a	b
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

 

	key	data1
0	b	0
1	b	1
2	a	2
3	c	3
4	a	4
5	a	5
6	b	6

df2

 

	key	data2
0	a	0
1	b	1
2	d	2

这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到

pd.merge(df1, df2)

 

	key	data1	data2
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')

 

	key	data1	data2
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')

 

	lkey	data1	rkey	data2
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')

 

	key	data1	data2
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

 

	key	data1
0	b	0
1	b	1
2	a	2
3	c	3
4	a	4
5	b	5

df2

 

	key	data2
0	a	0
1	b	1
2	a	2
3	b	3
4	d	4

pd.merge(df1, df2, on='key', how='left')

 

	key	data1	data2
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')

 

	key	data1	data2
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

 

	key1	key2	lval
0	foo	one	1
1	foo	two	2
2	bar	one	3

right

 

	key1	key2	rval
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')

 

	key1	key2	lval	rval
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')

 

	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

pd.merge(left, right, on='key1', suffixes=('_left', '_right'))

 

	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

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

 

	key	value
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)

 

	key	value	group_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')

 

	key	value	group_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

 

	key1	key2	data
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

 

		event1	event2
Nevada	2001	0	1
	2000	2	3
Ohio	2000	4	5
	2000	6	7
	2001	8	9
	2002	10	11

这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用how='outer’对重复索引值的处理）：

 pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)

 

	key1	key2	data	event1	event2
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')

 

	key1	key2	data	event1	event2
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

 

	Ohio	Nevada
a	1.0	2.0
c	3.0	4.0
e	5.0	6.0

right2

 

	Missouri	Alabama
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)

 

	Ohio	Nevada	Missouri	Alabama
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')

 

	Ohio	Nevada	Missouri	Alabama
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')

 

	key	value	group_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 York	Oregon
a	7.0	8.0
c	9.0	10.0
e	11.0	12.0
f	16.0	17.0

left2.join([right2, another])

 

	Ohio	Nevada	Missouri	Alabama	New York	Oregon
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)

 

	Ohio	Nevada	Missouri	Alabama	New York	Oregon
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.

 

	0	1	2
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.

 

	0	1
a	0.0	0
b	1.0	1
f	NaN	5
g	NaN	6

pd.concat([s1, s4], axis=1, join='inner')

 

	0	1
a	0	0
b	1	1

在这个例子中，f和g标签消失了，是因为使用的是join='inner’选项。

你可以通过join_axes指定要在其它轴上使用的索引：

pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])

 

	0	1
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()

 

	a	b	f	g
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.

 

	one	two	three
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

 

	one	two
a	0	1
b	2	3
c	4	5

df2

 

	three	four
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.

 

	level1		level2
	one	two	three	four
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.

 

	level1		level2
	one	two	three	four
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'.

 

upper	level1		level2
lower	one	two	three	four
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

 

	a	b	c	d
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

 

	b	d	a
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)

 

	a	b	c	d
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

 

	a	b	c
0	1.0	NaN	2
1	NaN	2.0	6
2	5.0	NaN	10
3	NaN	6.0	14

df2

 

	a	b
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)

 

	a	b	c
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

 

number	one	two	three
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()

 

number	one	two	three
state
Ohio	0	1	2
Colorado	3	4	5

默认情况下，unstack操作的是最内层（stack也是如此）。传入分层级别的编号或名称即可对其它级别进行unstack操作

result.unstack(0)

 

state	Ohio	Colorado
number
one	0	3
two	1	4
three	2	5

result.unstack('state')

 

state	Ohio	Colorado
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()

 

	a	b	c	d	e
one	0.0	1.0	2.0	3.0	NaN
two	NaN	NaN	4.0	5.0	6.0

stack默认会滤除缺失数据，因此该运算是可逆的：

data2.unstack()

 

	a	b	c	d	e
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

 

	side	left	right
state	number
Ohio	one	0	5
	two	1	6
	three	2	7
Colorado	one	3	8
	two	4	9
	three	5	10

df.unstack('state')

 

side	left		right
state	Ohio	Colorado	Ohio	Colorado
number
one	0	3	5	8
two	1	4	6	9
three	2	5	7	10

当调用stack，我们可以指明轴的名字：

df.unstack('state').stack('side')

 

	state	Colorado	Ohio
number	side
one	left	3	0
	right	8	5
two	left	4	1
	right	9	6
three	left	5	2
	right	10	7

将“长格式”旋转为“宽格式”

多个时间序列数据通常是以所谓的“长格式”（long）或“堆叠格式”（stacked）存储在数据库和CSV中的。我们先加载一些示例数据，做一些时间序列规整和数据清洗：

data = pd.read_csv('examples/macrodata.csv')

data.head()

 

	year	quarter	realgdp	realcons	realinv	realgovt	realdpi	cpi	m1	tbilrate	unemp	pop	infl	realint
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()

 

item	realgdp	infl	unemp
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()

 

item	realgdp	infl	unemp
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()

 

	date	item	value
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()

 

item	infl	realgdp	unemp
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()

 

	date	item	value	value2
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]

 

	value			value2
item	infl	realgdp	unemp	infl	realgdp	unemp
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]

 

item	infl	realgdp	unemp
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()

 

		value	value2
date	item
1959-03-31	realgdp	2710.349	-0.201684
	infl	0.000	-0.821067
	unemp	5.800	-0.520952
1959-06-30	realgdp	2778.801	1.085979
	infl	2.340	0.879421

unstacked = ldata.set_index(['date', 'item']).unstack('item')

unstacked[:7]

 

	value			value2
item	infl	realgdp	unemp	infl	realgdp	unemp
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

 

	key	A	B	C
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

 

	key	variable	value
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

 

variable	A	B	C
key
bar	2	5	8
baz	3	6	9
foo	1	4	7

因为pivot的结果从列创建了一个索引，用作行标签，我们可以使用reset_index将数据移回列：

reshaped.reset_index()

 

variable	key	A	B	C
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'])

 

	key	variable	value
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'])

 

	variable	value
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'])

 

	variable	value
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，学习更高级的分析。