Pandas(十四)--索引操作

目录

索引Index

创建索引

设置索引

重置索引

分层索引MultiIndex

创建分层索引

应用分层索引

分层索引切片取值

聚合函数应用

局部索引

行索引层转换为列索引

列索引实现分层

交换层和层排序

---

索引Index

通过索引(Index)可以从 DataFame 中选择特定的行数和列数，这种选择数据的方式称为“子集选择”。在 Pandas 中，索引值也被称为标签（label），它在 Jupyter 笔记本中以粗体字进行显示。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。

创建索引

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

1. import pandas as pd
2. data = pd.read_csv("person.csv")
3. print(data)

输出结果：

   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

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

1. import pandas as pd
2. #设置"Name"为行索引
3. data = pd.read_csv("person.csv", index_col ="Name")
4. # 通过列标签选取多列数据
5. a = data[["City","Salary"]]
6. print(a)

输出结果：

           City  Salary
Name                  
Jack    Beijing   22000
Lida   Shanghai   19000
John   Shenzhen   12000
Helen  Hengshui    3500

再看一组简单的示例：

1. import pandas as pd
2. info =pd.read_csv("person.csv", index_col ="Name")
3. #获取单列数据，或者以列表的形式传入["Salary"]
4. a =info["Salary"]
5. print(a)

输出结果：

       Salary
Name        
Jack    22000
Lida    19000
John    12000
Helen    3500

设置索引

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

1. info = pd.DataFrame({'Name': ['Parker', 'Terry', 'Smith', 'William'], 'Year': [2011, 2009, 2014, 2010],'Leaves': [10, 15, 9, 4]})
2. #设置Name为行索引
3. print(info.set_index('Name'))

输出结果：

         Year  Leaves
Name                
Parker   2011      10
Terry    2009      15
Smith    2014       9
William  2010       4

重置索引

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

1. import pandas as pd
2. import numpy as np
3. info = pd.DataFrame([('William', 'C'),
4. ('Smith', 'Java'),
5. ('Parker', 'Python'),
6. ('Phill', np.nan)],
7. index=[1, 2, 3, 4],
8. columns=('name', 'Language'))
9. print(info)
10. print(info.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

分层索引MultiIndex

分层索引（Multiple Index）指的是在一个轴上拥有多个（即两个以上）索引层数，这可以用低维度的结构来处理更高维的数据。当要处理三维及以上的高维数据时，就需要用到分层索引。分层索引的目的是用低维度的结构（Series 或者 DataFrame）更好地处理高维数据。分层索引的存在使得分析高维数据变得简单，让抽象的高维数据变得容易理解。

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

创建分层索引

1) 直接创建

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

1. import pandas as pd
2. import numpy as np
3. #为leves传递一个1行5列的二维数组
4. df=pd.MultiIndex(levels=[[np.nan, 2, pd.NaT, None, 5]], codes=[[4, -1, 1, 2, 3, 4]])
5. print(df.levels)
6. print(df)

输出结果：

[[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() 实现从元组创建分层索引。

1. #创建元组序列
2. arrays = [['it', 'it', 'of', 'of', 'for', 'for', 'then', 'then'],
3. ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
4. #使用zip()函数创建元组
5. tuples = list(zip(*arrays))

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

1. import pandas as pd
2. #创建了两层索引，并使用names对它们命名
3. index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
4. print(index)

输出结果：

MultiIndex([(  'it', 'one'),
            (  'it', 'two'),
            (  'of', 'one'),
            (  'of', 'two'),
            ( 'for', 'one'),
            ( 'for', 'two'),
            ('then', 'one'),
            ('then', 'two')],
           names=['first', 'second'])

3) 从DataFrame对象创建

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

1. #首先创建一个 DataFrame。
2. import pandas as pd
3. df = pd.DataFrame([['bar', 'one'], ['bar', 'two'],
4. ['foo', 'one'], ['foo', 'two']],
5. columns=['first', 'second'])
6. #然后使用 from_frame()创建分层索引。
7. index = pd.MultiIndex.from_frame(df)
8. #将index应用于Series
9. s=pd.Series(np.random.randn(4), index=index)
10. print(s)

输出结果：

first  second
bar    one       1.151928
       two      -0.694435
foo    one      -1.701611
       two      -0.486157
dtype: float64

4) 笛卡尔积创建

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

1. import pandas as pd
2. #构建数据
3. numbers = [0, 1, 2]
4. language = ['Python', 'Java']
5. #经过笛卡尔积处理
6. index = pd.MultiIndex.from_product([numbers, language],names=['number', 'language'])
7. #将分层索引对象应用于Series
8. dk_er=pd.Series(np.random.randn(6), index=index)
9. print(dk_er)

输出结果：

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() 方法，同样可以创建分层索引。示例如下：

1. import pandas as pd
2. df=pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'],[1, 2, 1, 2]])
3. df

输出结果：

MultiIndex([('a', 1),
            ('a', 2),
            ('b', 1),
            ('b', 2)],
           )

应用分层索引

下面示例如何在 DataFrame 中应用分层索引。把已经创建的分层索引应用到 DataFrame 中：

import pandas as pd
import numpy as np
#创建一个数组
arrays = [[0, 0, 1, 1], ['A', 'B', 'A', 'B']]
# 第一层为 number，该层有 0、1 两个元素，第二层为 letter，有两个字母 A 和 B。
index=pd.MultiIndex.from_arrays(arrays, names=('number', 'letter'))
#在行索引位置应用分层索引
df=pd.DataFrame([{'a':11, 'b':22}], index=index)
print(df)

输出结果：
                a   b
number letter       
0      A       11  22
       B       11  22
1      A       11  22
       B       11  22

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

import pandas as pd
df= pd.DataFrame({'a': range(5), 'b': range(5, 0, -1),
'c': ['one', 'one', 'one', 'two', 'two'],
'd': [0, 1, 2, 0, 1]})
print(df)
转换前：
   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

df1=df.set_index(['a','d'],drop=False)
print(df1)
转换后：
     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

df1=df.set_index(['a','d'],drop=False, append=Ture)
print(df2)
带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) 分层行索引操作

import pandas as pd
#构建多层索引
tuple = [('湖人',2008),('步行者',2008),('湖人',2007),('凯尔特人',2007), ('篮网',2007),('热火',2008)]
salary = [10000,20000,11000,30000,19000,22000]
#其次应用于DataFrame
index = pd.MultiIndex.from_tuples(tuple)
s = pd.Series(salary, index=index)
print(s)
输出结果：
湖人    2008    10000
步行者   2008    20000
湖人    2007    11000
凯尔特人  2007    30000
篮网    2007    19000
热火    2008    22000
dtype: int64

#切片取值
print(s['湖人',2007])
输出湖人队2007年工资：
11000

print(s['湖人'])
输出湖人队的工资：
2008    10000
2007    11000
dtype: int64

print(s[:,2008])
输出2008年所有队伍工资：
湖人     10000
步行者    20000
热火     22000
dtype: int64

#比较value
print(s[s<=20000])
输出小于等于20000的年份和队伍：
湖人   2008    10000
步行者  2008    20000
湖人   2007    11000
篮网   2007    19000
dtype: int64

2) 行、列多层索引操作

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

df = pd.DataFrame(np.arange(1,13).reshape((4, 3)), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], columns=[['Jack', 'Jack', 'Helen'],['Python', 'Java', 'Python']])
#选择同一层级的索引,切记不要写成['Jack','Helen']
print(df[['Jack','Helen']])
输出结果：
      Jack       Helen
    Python Java Python
a 1      1    2      3
  2      4    5      6
b 1      7    8      9
  2     10   11     12

#在不同层级分别选择索引
print(df['Jack','Python'])
输出结果：
a  1     1
   2     4
b  1     7
   2    10
Name: (Jack, Python), dtype: int32

#iloc整数索引
print(df.iloc[:3,:2])
输出结果：
      Jack    
    Python Java
a 1      1    2
  2      4    5
b 1      7    8

#loc列标签索引
print(df.loc[:,('Helen','Python')])
输出结果：
a  1     3
   2     6
b  1     9
   2    12
Name: (Helen, Python), dtype: int32

聚合函数应用

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

import pandas as pd
df = pd.DataFrame(np.arange(1,13).reshape((4, 3)), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], columns=[['Jack', 'Jack', 'Helen'], ['Python', 'Java', 'Python']])
#第一步，给行列层级起名字
df.index.names=['key1','key2']
df.columns.names=['name','course']

print(df.sum(level='key2'))
# 或者print(df.groupby(level='key2').sum())
#对key2层1/2对应的元素值求和
name     Jack       Helen
course Python Java Python
key2                    
1           8   10     12
2          14   16     18

print(df.mean(level="course",axis=1))
# 或者print(df.groupby(level="course",axis=1).mean())
#axis=1沿着水平方向求均值
course     Python  Java
key1 key2             
a    1          2     2
     2          5     5
b    1          8     8
     2         11    11

局部索引

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

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27], index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'], ['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
info['y']
输出结果：
obj1    19
obj2    32
obj3    34
obj4    27
dtype: int64

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

行索引层转换为列索引

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

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27], index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'], ['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
#行索引标签默认是最外层的 x, y
#0代表第一层索引，而1代表第二层
print(info.unstack(0))
输出结果：
x y
obj1 11 19
obj2 14 32
obj3 17 34
obj4 24 27

# unstack(0) 表示选择第一层索引作为列，unstack(1) 表示选择第二层：
print(info.unstack(1))
输出结果：
   obj1  obj2  obj3  obj4
x    11    14    17    24
y    19    32    34    27

列索引实现分层

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

import numpy as np
info = pd.DataFrame(np.arange(12).reshape(4, 3), index = [['a', 'a', 'b', 'b'], ['one', 'two', 'three', 'four']], columns = [['num1', 'num2', 'num3'], ['x', 'y', 'x']] )
print(info)
输出结果：
        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() 方法轻松地实现索引层交换，示例如下：

import pandas as pd
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']])
#设置index的levels名称
frame.index.names = ['key1', 'key2']
#设置columns的levels名称
frame.columns.names = ['state','color']

#交换key1层与key层
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

2) 层排序

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

print(frame.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