pandas基础--层次化索引

pandas含有是数据分析工作变得更快更简单的高级数据结构和操作工具，是基于numpy构建的。

本章节的代码引入pandas约定为：import pandas as pd，另外import numpy as np也会用到。

官方介绍：pandas - Python Data Analysis Library (pydata.org)

8 层次化索引

层次化索引使你能在一个轴上拥有多个（两个以上）索引级别。抽象的说，它使你能以低维度形式处理高维度数据。

 1 >>> data = pd.Series(np.random.randn(10), index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'], [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
 2 >>> data
 3 a  1    3.230188
 4    2    0.596511
 5    3    0.956307
 6 b  1    1.132221
 7    2    0.746174
 8    3    0.470007
 9 c  1    0.880883
10    2    0.757047
11 d  2   -0.028331
12    3    0.382625
13 dtype: float64
14 >>> data.index #带MultiIndex索引的Series的格式化输出形式，索引之间的“间隔”表示“直接使用上面的标签”
15 MultiIndex([('a', 1),
16             ('a', 2),
17             ('a', 3),
18             ('b', 1),
19             ('b', 2),
20             ('b', 3),
21             ('c', 1),
22             ('c', 2),
23             ('d', 2),
24             ('d', 3)],
25            )
26 >>> data['b']  #选取数据子集
27 1    1.132221
28 2    0.746174
29 3    0.470007
30 dtype: float64
31 >>> data['b': 'c']
32 b  1    1.132221
33    2    0.746174
34    3    0.470007
35 c  1    0.880883
36    2    0.757047
37 dtype: float64
38 >>> data.loc[['b', 'd']]
39 b  1    1.132221
40    2    0.746174
41    3    0.470007
42 d  2   -0.028331
43    3    0.382625
44 dtype: float64
45 >>> data[:, 2]  #在“内层”中进行选取
46 a    0.596511
47 b    0.746174
48 c    0.757047
49 d   -0.028331
50 dtype: float64

层次索引在数据重塑和基于和基于分组的操作（如透视表生成）中有重要作用。

如可以通过unstack方法重新安排多层数据到一个DataFrame中。

官方说明：pandas.DataFrame.unstack — pandas 1.3.4 documentation (pydata.org)

 1 >>> data
 2 a  1    3.230188
 3    2    0.596511
 4    3    0.956307
 5 b  1    1.132221
 6    2    0.746174
 7    3    0.470007
 8 c  1    0.880883
 9    2    0.757047
10 d  2   -0.028331
11    3    0.382625
12 dtype: float64
13 >>> data.unstack()
14           1         2         3
15 a  3.230188  0.596511  0.956307
16 b  1.132221  0.746174  0.470007
17 c  0.880883  0.757047       NaN
18 d       NaN -0.028331  0.382625
19 >>> data.unstack().stack()  #stack使unstack的逆运算
20 a  1    3.230188
21    2    0.596511
22    3    0.956307
23 b  1    1.132221
24    2    0.746174
25    3    0.470007
26 c  1    0.880883
27    2    0.757047
28 d  2   -0.028331
29    3    0.382625
30 dtype: float64

对于一个DataFrame，每条轴都可以分成索引，每层都可以由名字（可能是字符串，也可以是别的python对象）。如果指定了名字，它们就会显示在控制台输出中。

 1 >>> frame = pd.DataFrame(np.arange(12).reshape((4, 3)), index=[['a', 'a', 'b', 'b'], [1, 2, 1, -2]], columns=[['Oh', 'Oh', 'Co'], ['Gr', 'Re', 'Gr']])
 3 >>> frame
 4      Oh      Co
 5      Gr  Re  Gr
 6 a  1  0   1   2
 7    2  3   4   5
 8 b  1  6   7   8
 9   -2  9  10  11
10 >>> frame.index.names = ['key1', 'key2']
11 >>> frame.columns.names = ['state', 'color']
12 >>> frame
13 state     Oh      Co
14 color     Gr  Re  Gr
15 key1 key2
16 a     1    0   1   2
17       2    3   4   5
18 b     1    6   7   8
19      -2    9  10  11
20 >>> frame['Oh']
21 color      Gr  Re
22 key1 key2
23 a     1     0   1
24       2     3   4
25 b     1     6   7
26      -2     9  10

8.1 重排分级排序

有时需要调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。

swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（当数据不会发生变化）。

官方文档：pandas.DataFrame.swaplevel — pandas 1.3.4 documentation (pydata.org)

 1 >>> frame
 2 state     Oh      Co
 3 color     Gr  Re  Gr
 4 key1 key2
 5 a     1    0   1   2
 6       2    3   4   5
 7 b     1    6   7   8
 8      -2    9  10  11
 9 >>> frame.swaplevel('key1', 'key2')
10 state     Oh      Co
11 color     Gr  Re  Gr
12 key2 key1
13  1   a     0   1   2
14  2   a     3   4   5
15  1   b     6   7   8
16 -2   b     9  10  11

8.2 根据级别汇总统计

许多对DataFrame和Series的描述和汇总统计都有一个level选项，用于指定在某条轴上求和的级别。

 1 >>> frame
 2 state     Oh      Co
 3 color     Gr  Re  Gr
 4 key1 key2
 5 a     1    0   1   2
 6       2    3   4   5
 7 b     1    6   7   8
 8      -2    9  10  11
 9 >>> frame.sum(level='key2')
10 state Oh      Co
11 color Gr  Re  Gr
12 key2
13  1     6   8  10
14  2     3   4   5
15 -2     9  10  11
16 >>> frame.sum(level='color', axis=1)
17 color      Gr  Re
18 key1 key2
19 a     1     2   1
20       2     8   4
21 b     1    14   7
22      -2    20  10
23 >>>

8.3 使用DataFrame的列

经常将DataFrame的一个或多个列当作行索引来使用，或者希望将行索引变成DataFrame的列。

DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame。

 1 >>> 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]})
 2 >>> frame
 3    a  b    c  d
 4 0  0  7  one  0
 5 1  1  6  one  1
 6 2  2  5  one  2
 7 3  3  4  two  0
 8 4  4  3  two  1
 9 5  5  2  two  2
10 6  6  1  two  3
11 >>> frame2 = frame.set_index(['c', 'd'])
12 >>> frame2
13        a  b
14 c   d
15 one 0  0  7
16     1  1  6
17     2  2  5
18 two 0  3  4
19     1  4  3
20     2  5  2
21     3  6  1
22 >>> frame.set_index(['c', 'd'], drop=False)  #可选择保留那些列
23        a  b    c  d
24 c   d
25 one 0  0  7  one  0
26     1  1  6  one  1
27     2  2  5  one  2
28 two 0  3  4  two  0
29     1  4  3  two  1
30     2  5  2  two  2
31     3  6  1  two  3

reset_index的功能和set_index刚好相反、层次化索引的级别会被转移到列里面：

 1 >>> frame2
 2        a  b
 3 c   d
 4 one 0  0  7
 5     1  1  6
 6     2  2  5
 7 two 0  3  4
 8     1  4  3
 9     2  5  2
10     3  6  1
11 >>> frame2.reset_index()
12      c  d  a  b
13 0  one  0  0  7
14 1  one  1  1  6
15 2  one  2  2  5
16 3  two  0  3  4
17 4  two  1  4  3
18 5  two  2  5  2
19 6  two  3  6  1