pandas索引

索引

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

在 Pandas 中，索引值也被称为标签（label）。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。

# 做一张成绩表df_obj1(3,3)
score = np.random.randint(0,100,(3,3))
score = pd.DataFrame(score,index=['小明','小红','小张'],columns=['语文','数学','英语'])
print(score)

''' 
	语文	数学	英语
小明	52	83	2
小红	68	4	9
小张	74	82	26
'''

我们可以使用列索引的方式来获取一列数据，返回的结果是一个Series对象

element = score['语文']
print(element)
'''
小明    62
小红    75
小张    68
Name: 语文, dtype: int32
'''

# 增加一列数据
score['科学'] = [80,80,80]
print(score)
'''
    语文  数学  英语  科学
小明  62  57  17  80
小红  75   5  18  80
小张  68  19  55  80
'''

# 删除某一列数据
del score['科学']
print(score)
'''
    语文  数学  英语
小明  62  57  17
小红  75   5  18
小张  68  19  55
'''

重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

ser_obj = pd.Series(range(5),index=['a','b','c','d','e'])
ser_index = ser_obj.index
print(ser_index)
'''
Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
'''

# 重新索引
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'])
print(ser_obj2)
'''
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
f    NaN
dtype: float64
'''

ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'],fill_value=6)
print(ser_obj2)
'''
a    0
b    1
c    2
d    3
e    4
f    6
dtype: int64
'''

ser_obj = pd.Series(range(5),index=['a','b','c','d','e'])
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'])
# 前向填充值 ffill 或 pad
# 后向填充值 bfill 或 backfill
# nearest 从最近的索引值填充
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'],method='ffill')
print(ser_obj2)
'''
a    0
b    1
c    2
d    3
e    4
f    4
dtype: int64
'''

索引操作

访问 Series 序列中元素的两种方式：

• 位置索引访问
• 索引标签访问。

import pandas as pd
ser_obj = pd.Series([1,2,3,4,5],index=['a','b','c','d','e'])
print(ser_obj[2]) # 使用索引位置获取数据
'''
3
'''
print(ser_obj['c'])
'''
3
'''
print(ser_obj[2:4])
'''
3
c    3
d    4
dtype: int64
'''

print(ser_obj['c':'e'])
'''
3
c    3
d    4
e    5
dtype: int64
'''
print(ser_obj[[0,2,4]])
'''
a    1
c    3
e    5
dtype: int64
'''
print(ser_obj[['a','c','d']])
'''
dtype: int64
a    1
c    3
d    4
dtype: int64
'''

ser_bool = ser_obj > 2 # 创建布尔型Series对象
print(ser_bool)
'''
a    False
b    False
c     True
d     True
e     True
dtype: bool
'''
print(ser_obj[ser_bool])
'''
c    3
d    4
e    5
dtype: int64
'''

层次化索引

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

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

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

mulitindex_series = pd.Series([15848,13472,12073.8,7813,
                               7446,6444,15230,8269],
      index=[['河北省','河北省','河北省','河北省',
                    '河南省','河南省','河南省','河南省'],
                   ['石家庄市','唐山市','邯郸市','秦皇岛市',
                    '郑州市','开封市','洛阳市','新乡市']])
print(mulitindex_series)
'''
河北省  石家庄市    15848.0
     唐山市     13472.0
     邯郸市     12073.8
     秦皇岛市     7813.0
河南省  郑州市      7446.0
     开封市      6444.0
     洛阳市     15230.0
     新乡市      8269.0
dtype: float64
'''
mulitindex_df = pd.DataFrame({'占地面积':[15848,13472,12073.8,7813,
                               7446,6444,15230,8269]},
      index=[['河北省','河北省','河北省','河北省',
                    '河南省','河南省','河南省','河南省'],
                   ['石家庄市','唐山市','邯郸市','秦皇岛市',
                    '郑州市','开封市','洛阳市','新乡市']])
print(mulitindex_df)
'''
             占地面积
河北省 石家庄市  15848.0
    唐山市   13472.0
    邯郸市   12073.8
    秦皇岛市   7813.0
河南省 郑州市    7446.0
    开封市    6444.0
    洛阳市   15230.0
    新乡市    8269.0
'''

MultiIndex类提供了3种创建层次化索引的方法：

1. MultiIndex.from_tuples()：将元组列表转换为MultiIndex。
2. MultiIndex.from_arrays()：将数组列表转换为MultiIndex。
3. MultiIndex.from_product()：从多个集合的笛卡尔乘积中创建一个MultiIndex。

from pandas import MultiIndex

# from_tuples()方法可以将包含若干个元组的列表转换为MultiIndex对象，其中元组的第一个元素作为外层索引，元组的第二个元素作为内层索引。
list_tuples = [('A','A1'), ('A','A2'), ('B','B1'),('B','B2'), ('B','B3')]
# 根据元组列表创建一个MultiIndex对象
multi_index = MultiIndex.from_tuples(tuples=list_tuples, 
                        names=[ '外层索引', '内层索引'])
print(multi_index)
'''
MultiIndex([('A', 'A1'),
            ('A', 'A2'),
            ('B', 'B1'),
            ('B', 'B2'),
            ('B', 'B3')],
           names=['外层索引', '内层索引'])
'''
values = np.array([[1,2,3],[8,5,7],[4,7,7],[5,5,4],[4,9,9]])
df_indexs = pd.DataFrame(data=values,index=multi_index)
print(df_indexs)
'''
           0  1  2
外层索引 内层索引         
A    A1    1  2  3
     A2    8  5  7
B    B1    4  7  7
     B2    5  5  4
     B3    4  9  9
'''

# from_arrays()方法是将数组列表转换为MultiIndex对象，其中嵌套的第一个列表将作为外层索引，嵌套的第二个列表将作为内层索引。
multi_array = MultiIndex.from_arrays(arrays =[['A', 'B', 'A', 'B', 'B'], 
                                              ['A1', 'A2', 'B1', 'B2', 'B3']],
                                names=['外层索引','内层索引'])
print(multi_array)
'''
MultiIndex([('A', 'A1'),
            ('B', 'A2'),
            ('A', 'B1'),
            ('B', 'B2'),
            ('B', 'B3')],
           names=['外层索引', '内层索引'])
'''
values = np.array([[1,2,3],[8,5,7],[4,7,7],[5,5,4],[4,9,9]])
df_array = pd.DataFrame(data=values,index=multi_array)
print(df_array)
'''
           0  1  2
外层索引 内层索引         
A    A1    1  2  3
B    A2    8  5  7
A    B1    4  7  7
B    B2    5  5  4
     B3    4  9  9
'''

# from_product()方法表示从多个集合的笛卡尔乘积中创建一个MultiIndex对象。
numbers = [0, 1, 2]
colors = ['green', 'purple']
multi_product = pd.MultiIndex.from_product(iterables=[numbers, colors], 
						   names=['number', 'color'])
print(multi_product)
'''
MultiIndex([(0,  'green'),
            (0, 'purple'),
            (1,  'green'),
            (1, 'purple'),
            (2,  'green'),
            (2, 'purple')],
           names=['number', 'color'])
'''
import pandas as pd
values = np.array([1,2,3,4,5,6])
df_product = pd.DataFrame(data=values,index=multi_product)
print(df_product)
'''
               0
number color    
0      green   1
       purple  2
1      green   3
       purple  4
2      green   5
       purple  6
'''