笔记小结：《利用python进行数据分析》之层次化索引

层次化索引

导入样例

层次化索引（hierarchical indexing）是pandas的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：

In [9]: 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]])
In [10]: data
Out[10]: 
a  1   -0.204708
   2    0.478943
   3   -0.519439
b  1   -0.555730
   3    1.965781
c  1    1.393406
   2    0.092908
d  2    0.281746
   3    0.769023
dtype: float64

看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”。

MultiIndex对象

In [11]: data.index
Out[11]: 
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]])

输出结果是一个MultiIndex对象，它是由两个层级组成的多级索引。这个多级索引的结构如下：

• levels：这是两个列表的列表，表示索引的两个级别。第一个列表包含大写字母['a', 'b', 'c', 'd']，这是索引的第一级；第二个列表包含数字[1, 2, 3]，这是索引的第二级。
• labels：这是一个二维数组，表示每个索引元素在levels中的位置。labels的第一行对应于levels的第一级，第二行对应于levels的第二级。例如，labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]]表示：
  • 第一个元素的索引是('a', 1)
  • 第二个元素的索引是('a', 2)
  • 第三个元素的索引是('a', 3)
  • 以此类推...

这种多级索引在数据分析中非常有用，便于对数据进行更复杂的分组和操作。

索引和切片操作

对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：

In [12]: data['b']
Out[12]: 
1   -0.555730
3    1.965781
dtype: float64
In [13]: data['b':'c']
Out[13]: 
b  1   -0.555730
   3    1.965781
c  1    1.393406
   2    0.092908
dtype: float64
In [14]: data.loc[['b', 'd']]
Out[14]: 
b  1   -0.555730
   3    1.965781
d  2    0.281746
   3    0.769023
dtype: float64

1. data['b']：这个操作是使用第一级索引（即大写字母）来选择所有与'b'相关的元素。输出结果显示了所有索引为'b'的Series元素。

2. data['b':'c']：这个操作是使用索引的切片功能，选择了从'b'到'c'（包含'b'和'c'）的所有元素。输出结果展示了索引在'b'和'c'之间的所有Series元素。

3. data.loc[['b', 'd']]：这个操作使用了.loc属性，它允许通过提供一个索引列表来选择数据。这里选择了索引为'b'和'd'的所有元素。输出结果展示了这两个索引下的所有Series元素。

基于标签在内层进行索引

有时甚至还可以在“内层”中进行选取：

In [15]: data.loc[:, 2]
Out[15]: 
a    0.478943
c    0.092908
d    0.281746
dtype: float64

在您的代码片段 data.loc[:, 2] 中，使用了 .loc 属性来进行基于标签的索引操作。这里的操作是选择所有第一级索引（即大写字母 'a', 'b', 'c', 'd'）下，第二级索引为 2 的所有数据。下面是具体的解释：

• data：是之前创建的Pandas Series对象，具有多级索引。
• .loc：是Pandas中用于基于标签的索引操作的属性。
• [:, 2]：这个索引器指定了要选择的行和列。在这个例子中，冒号 : 表示选择所有的第一级索引（即所有的大写字母），而数字 2 表示选择第二级索引中的2。由于您的数据集中第二级索引是数字1、2、3，所以这里的2将匹配所有索引为2的元素。

输出结果 Out[15] 展示了所有第二级索引为2的元素，即：

• 'a' 下索引为2的元素，值为 0.478943
• 'c' 下索引为2的元素，值为 0.092908
• 'd' 下索引为2的元素，值为 0.281746

注意，尽管索引 'b' 存在，但在数据集中并没有索引为 ('b', 2) 的元素，因此在输出结果中没有显示。这种索引方式非常适合于选择特定级别的索引数据，无论是行还是列。

stack与unstack方法

层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：

In [16]: data.unstack()
Out[16]: 
          1         2         3
a -0.204708  0.478943 -0.519439
b -0.555730       NaN  1.965781
c  1.393406  0.092908       NaN
d       NaN  0.281746  0.769023

unstack的逆运算是stack：

In [17]: data.unstack().stack()
Out[17]: 
a  1   -0.204708
   2    0.478943
   3   -0.519439
b  1   -0.555730
   3    1.965781
c  1    1.393406
   2    0.092908
d  2    0.281746
   3    0.769023
dtype: float64

每条轴的分层索引

对于一个DataFrame，每条轴都可以有分层索引：

In [18]: 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']])
In [19]: frame
Out[19]: 
     Ohio     Colorado
    Green Red    Green
a 1     0   1        2
  2     3   4        5
b 1     6   7        8
  2     9  10       11

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

In [20]: frame.index.names = ['key1', 'key2']
In [21]: frame.columns.names = ['state', 'color']
In [22]: frame
Out[22]: 
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

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

In [23]: frame['Ohio']
Out[23]: 
color      Green  Red
key1 key2            
a    1         0    1
     2         3    4
b    1         6    7
     2         9   10

单独创建MultiIndex然后复用

可以单独创建MultiIndex然后复用。上面那个DataFrame中的（带有分级名称）列可以这样创建：

MultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
                       names=['state', 'color'])

重排与分级排序

swaplevel

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

In [24]: frame.swaplevel('key1', 'key2')
Out[24]: 
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则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：

In [25]: frame.sort_index(level=1)
Out[25]: 
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
In [26]: frame.swaplevel(0, 1).sort_index(level=0)
Out[26]: 
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为例，我们可以根据行或列上的级别来进行求和：

In [27]: frame.sum(level='key2')
Out[27]: 
state  Ohio     Colorado
color Green Red    Green
key2                    
1         6   8       10
2        12  14       16
In [28]: frame.sum(level='color', axis=1)
Out[28]: 
color      Green  Red
key1 key2            
a    1         2    1
     2         8    4
b    1        14    7
     2        20   10

使用DataFrame的列进行索引

人们经常想要将DataFrame的一个或多个列当做行索引来用，或者可能希望将行索引变成DataFrame的列。以下面这个DataFrame为例：

In [29]: 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]})
In [30]: frame
Out[30]: 
   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：

In [31]: frame2 = frame.set_index(['c', 'd'])
In [32]: frame2
Out[32]: 
       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中移除，但也可以将其保留下来：

In [33]: frame.set_index(['c', 'd'], drop=False)
Out[33]: 
       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刚好相反，层次化索引的级别会被转移到列里面：

In [34]: frame2.reset_index()
Out[34]:
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