pandas之索引操作

索引（index）是 Pandas 的重要工具，通过索引可以从 DataFame 中选择特定的行数和列数，这种选择数据的方式称为“子集选择”。

在 Pandas 中，索引值也被称为标签（label），它在 Jupyter 笔记本中以粗体字进行显示。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。

创建索引

通过示例对 index 索引做进一步讲解。下面创建一个带有 index 索引的数据，并使用 read_csv() 这些读取数据：

输出结果：

   ID   Name  Age      City  Salary

0   1   Jack   28   Beijing   22000

1   2   Lida   32  Shanghai   19000

2   3   John   43  Shenzhen   12000

3   4  Helen   38  Hengshui    3500

通过列索引（标签）读取多列数据。

输出结果：

           City  Salary

Name

Jack    Beijing   22000

Lida   Shanghai   19000

John   Shenzhen   12000

Helen  Hengshui    3500

再看一组简单的示例：

输出结果：

       Salary

Name

Jack    22000

Lida    19000

John    12000

Helen    3500

设置索引

set_index() 将已存在的列标签设置为 DataFrame 行索引。除了可以添加索引外，也可以替换已经存在的索引。比如您也可以把 Series 或者一个 DataFrme 设置成另一个 DataFrame 的索引。示例如下：

输出结果：

         Year  Leaves

Name

Parker   2011      10

Terry    2009      15

Smith    2014       9

William  2010       4

重置索引

您可以使用 reset_index() 来恢复初始行索引，示例如下：

输出结果：

重置前：

     name    Language

1  William        C

2    Smith     Java

3   Parker   Python

4    Phill      NaN

重置后：

   index     name    Language

0      1  William        C

1      2    Smith     Java

2      3   Parker   Python

3      4    Phill      NaN

---------------------------------------------------------------------------------------

分层索引（Multiple Index）是 Pandas 中非常重要的索引类型，它指的是在一个轴上拥有多个（即两个以上）索引层数，这使得我们可以用低维度的结构来处理更高维的数据。比如，当想要处理三维及以上的高维数据时，就需要用到分层索引。

分层索引的目的是用低维度的结构（Series 或者 DataFrame）更好地处理高维数据。通过分层索引，我们可以像处理二维数据一样，处理三维及以上的数据。分层索引的存在使得分析高维数据变得简单，让抽象的高维数据变得容易理解，同时它比废弃的 Panel 结构更容易使用。

Pandas 可以通过 MultiIndex() 方法来创建分层索引对象，该对象本质上是一个元组序列，序列中每一个元组都是唯一的。下面介绍几种创建分层索引的方式。

创建分层索引

1) 直接创建

通过 MultiIndex() 的levels参数能够直接创建分层索引，示例如下：

输出结果：

[[nan, 2, NaT, None, 5]]

MultiIndex([(  5,),

            (nan,),

            (  2,),

            (nan,),

            (nan,),

            (  5,)],

           )

上述代码中，levels参数用来创建层级索引，这里只有一层，该层的索引值分别是 np.nan, 2, NaT, None, 5；codes表示按参数值对层级索引值排序（与 levels 中的值相对应），也就说 codes 中数值是 leves 序列的下标索引。需要注意，这里的 -1 代表 NaN。

2) 从元组创建

通过 from_tuples() 实现从元组创建分层索引。

输出结果如下：

[('it', 'one'),

('it', 'two'),

('of', 'one'),

('of', 'two'),

('for', 'one'),

('for', 'two'),

('then', 'one'),

('then', 'two')]

然后使用 tuples 创建分层索引，如下所示：

输出结果：

MultiIndex([(  'it', 'one'),

            (  'it', 'two'),

            (  'of', 'one'),

            (  'of', 'two'),

            ( 'for', 'one'),

            ( 'for', 'two'),

            ('then', 'one'),

            ('then', 'two')],

           names=['first', 'second'])

3) 从DataFrame对象创建

通过 from_frame() 创建分层索引，示例如下：

输出结果：

first  second

bar    one       1.151928

       two      -0.694435

foo    one      -1.701611

       two      -0.486157

dtype: float64

4) 笛卡尔积创建

笛卡尔积（又称直积）是数学运算的一种方式，下面使用 from_product() 笛卡尔积创建分层索引。

输出结果：

number  language

0       Python     -0.319739

        Java        1.599170

1       Python     -0.010520

        Java        0.262068

2       Python     -0.124177

        Java        0.315120

dtype: float64

5) 数组创建分层索引

通过 from_array() 方法，同样可以创建分层索引。示例如下：

输出结果：

MultiIndex([('a', 1),

            ('a', 2),

            ('b', 1),

            ('b', 2)],

           )

应用分层索引

下面示例讲解了如何在 DataFrame 中应用分层索引。

输出结果

MultiIndex([(0, 'A'),

            (0, 'B'),

            (1, 'A'),

            (1, 'B')],

           names=['number', 'letter'])

上述示例中，第一层为 number，该层有 0、1 两个元素，第二层为 letter，有两个字母 A 和 B。

下面把已经创建的分层索引应用到 DataFrame 中，如下所示：

输出结果：

                a   b

number letter

0      A       11  22

       B       11  22

1      A       11  22

       B       11  22

通过 set_index() 可以将 DataFrame 的已有列的标索设置为 index 行索引，示例如下：

输出结果：

转换前：

   a  b    c  d

0  0  5  one  0

1  1  4  one  1

2  2  3  one  2

3  3  2  two  0

4  4  1  two  1

转换后：

     a  b    c  d

a d

0 0  0  5  one  0

1 1  1  4  one  1

2 2  2  3  one  2

3 0  3  2  two  0

4 1  4  1  two  1

带append参数：

       a  b    c  d

  a d            

0 0 0  0  5  one  0

1 1 1  1  4  one  1

2 2 2  2  3  one  2

3 3 0  3  2  two  0

4 4 1  4  1  two  1

通过 set_index() 将列索引转换为了分层行索引，其中 drop=False 表示更新索引的同时，不删除 a、d 列；同时，该函数还提供了一个 append = Ture 参数表示不添加默认的整数索引值（0到4）

分层索引切片取值

下面讲解分层索引切片取值操作，示例如下：

1) 分层行索引操作

输出结果：

湖人    2008    10000

步行者   2008    20000

湖人    2007    11000

凯尔特人  2007    30000

篮网    2007    19000

热火    2008    22000

dtype: int64

湖人队2007年工资：

11000

湖人队的工资：

2008    10000

2007    11000

dtype: int64

2008年所有队伍工资：

湖人     10000

步行者    20000

热火     22000

dtype: int64

小于等于20000的年份和队伍：

湖人   2008    10000

步行者  2008    20000

湖人   2007    11000

篮网   2007    19000

dtype: int64

2) 行、列多层索引操作

下面看一种更加复杂的情况，就是行、列同时存在多层索引时候，应该如何通过切片取值。示例如下：

输出结果：

      Jack       Helen

    Python Java Python

a 1      1    2      3

  2      4    5      6

b 1      7    8      9

  2     10   11     12

a  1     1

   2     4

b  1     7

   2    10

Name: (Jack, Python), dtype: int32

      Jack

    Python Java

a 1      1    2

  2      4    5

b 1      7    8

a  1     3

   2     6

b  1     9

   2    12

Name: (Helen, Python), dtype: int32

聚合函数应用

通过给level传递参数值，您可以指定在哪个层上进行聚合操作，比如求和、求均值等。示例如下：

输出结果：

#对key2层1/2对应的元素值求和

name     Jack       Helen

course Python Java Python

key2

1           8   10     12

2          14   16     18

#axis=1沿着水平方向求均值

course     Python  Java

key1 key2

a    1          2     2

     2          5     5

b    1          8     8

     2         11    11

在数据分析的过程中，我们把大部分时间都花费在数据的准备和预处理上，Pandas 作为一个灵活、高效的数据预处理工具，提供了诸多数据处理的方法，分层索引（Multiple Index）就是其中之一，分层索引（或多层索引）是 Pandas 的基本特性，它能够增强 Pands 数据预处理的能力。

对于 Series 结构来说，通过给index参数传递一个二维数组就可以创建一个具有两层索引的 MultiIndex 对象，示例如下：

输出结果：

x  obj1    11

   obj2    14

   obj3    17

   obj4    24

y  obj1    19

   obj2    32

   obj3    34

   obj4    27

dtype: int64

上述示例，创建了两个层级的索引，即 (x, y) 和 (obj1，…， obj4)，您可以使用 'index' 命令查看索引。

info.index

输出结果：

MultiIndex([('x', 'obj1'),

            ('x', 'obj2'),

            ('x', 'obj3'),

            ('x', 'obj4'),

            ('y', 'obj1'),

            ('y', 'obj2'),

            ('y', 'obj3'),

            ('y', 'obj4')],

           )

此外，您还可以基于内部索引层（也就是'obj'）来选择数据。如下所示：

info [:,'obj2' ]

输出结果：

x    14

y    32

dtype: int64

局部索引

局部索引可以理解为：从分层索引中选择特定索引层的一种方法。比如在下列数据中，选择所有'y'索引指定的数据，示例如下：

输出结果：

obj1    19

obj2    32

obj3    34

obj4    27

dtype: int64

当然您也可以基于内层索引选择数据。

行索引层转换为列索引

unstack() 用来将行索引转变成列索引，相当于转置操作。通过 unstack() 可以将 Series（一维序列）转变为 DataFrame（二维序列）。示例如下：

输出结果：

从示例可以看出，unstack(0) 表示选择第一层索引作为列，unstack(1) 表示选择第二层，如下所示：

输出结果：

   obj1  obj2  obj3  obj4

x    11    14    17    24

y    19    32    34    27

列索引实现分层

我们知道，列索引存在于 DataFrame 结构中，下面创建一个 DataFrame 来演示列索引如何实现分层。

输出结果：

        num1 num2 num3

           x    y    x

a one      0    1    2

  two      3    4    5

b three    6    7    8

  four     9   10   11

查看所有列索引：

info.columns

输出结果：

MultiIndex([('num1', 'x'),

            ('num2', 'y'),

            ('num3', 'x')],)

交换层和层排序

1) 交换层

通过 swaplevel() 方法轻松地实现索引层交换，示例如下：

输出结果：

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

2) 层排序

通过 sort_index() 的level参数实现对层的排序。下面示例，按“key1”的字母顺序重新排序。

输出结果：

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

pandas之索引操作

创建索引

设置索引

重置索引

创建分层索引

1) 直接创建

2) 从元组创建

3) 从DataFrame对象创建

4) 笛卡尔积创建

5) 数组创建分层索引

应用分层索引

通过 set_index() 可以将 DataFrame 的已有列的标索设置为 index 行索引，示例如下：

分层索引切片取值

1) 分层行索引操作

2) 行、列多层索引操作

聚合函数应用

局部索引

行索引层转换为列索引

列索引实现分层

交换层和层排序

1) 交换层

2) 层排序