索引对象
pandas的索引对象负责管理轴标签和其他元数据(比如轴名称等)。构建series或DataFrame时，所用到的任何数组或其他序列的标签都会转换成一个index：
In [1]: import pandas as pd In [2]: import numpy as np In [3]: from pandas import Series In [4]: obj=Series(range(3),index=['a','b','c']) In [5]: index=obj.index In [6]: index Out[6]: Index(['a', 'b', 'c'], dtype='object') In [7]: index[1:] Out[7]: Index(['b', 'c'], dtype='object')
index对象是不可修改的(immutable)，因此用户不能对其进行修改
In [8]: index[1]='d' --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-8be6e68dba2d> in <module>() ----> 1 index[1]='d' d:pythonpython36libsite-packagespandascoreindexesase.py in __setitem__(self, key, value) 2048 2049 def __setitem__(self, key, value): -> 2050 raise TypeError("Index does not support mutable operations") 2051 2052 def __getitem__(self, key): TypeError: Index does not support mutable operations
不可修改性非常重要，因为这样才能使Index对象在多个数据结构之间安全共享：
In [9]: index=pd.Index(np.arange(3)) In [10]: obj2=Series([1.5,-2.5,0],index=index) In [11]: obj2.index is index Out[11]: True In [12]: obj2.index Out[12]: Int64Index([0, 1, 2], dtype='int64')
Index类为pandas库中内置的类。
pandas中主要的index对象：
1.index 最泛化的Index对象，将轴标签表示为一个由python对象组成的Numpy数组
2.Int64Index 针对整数的特殊Index
3.MultilIndex “层次化”索引对象，表示单个轴上的多层索引。可以看做由元组组成的数组。
4.DatatimeIndex 存储纳秒级时间戳（用Numpy的datatime64类型表示）
5.PeriodIndex 针对Period数据(时间间隔)的特殊Index
Index的方法和属性
append 连接另一个Index对象，产生一个新的Index
diff 计算差集，并得到一个Index
intersection 计算交集
union 计算并集
isin 计算一个指示各值是否都包含在参数集合那种的布尔型数组
delete 删除索引i处的元素，并得到一个新的Index
drop 删除传入的值，并得到新的Index
insert 将元素插入到索引i处，并得到一个新的Index
is_monotonic 当各元素均大于等于前一个元素时，返回True
is_unique 当Index没有重复值时，返回True
unique 计算Index中唯一值的数组
重新索引
pandas对象的一个重要方法是reindex，其作用是创建一个适应新索引的新对象。
In [16]: obj=Series([4.5,7.3,-5.3,3.6],index=['d','b','a','c']) In [17]: obj Out[17]: d 4.5 b 7.3 a -5.3 c 3.6 dtype: float64
调用该Series的reindex将会根据新索引进行重排。如果当某个索引值当前不存在，就引入缺失值：
In [18]: obj2=obj.reindex(['a','b','c','d','e']) In [19]: obj2 Out[19]: a -5.3 b 7.3 c 3.6 d 4.5 e NaN dtype: float64
In [22]: obj.reindex(['a','b','c','d','e'],fill_value=0) Out[22]: a -5.3 b 7.3 c 3.6 d 4.5 e 0.0 dtype: float64
对于时间序列这样的有序数据，重新索引可能需要做一些插值处理。method选项可以达到这个目的。
使用ffill可以实现前向值填充：
In [23]: obj3=Series(['blue','purple','yellow'],index=[0,2,4]) In [24]: obj3.reindex(range(6),method='ffill') Out[24]: 0 blue 1 blue 2 purple 3 purple 4 yellow 5 yellow dtype: object
reindex的(插值)method选项：
ffill 或pad 前向填充(或搬运)值
bfill 或backfill 后向填充(或搬运)值
对于DataFrame，reindex可以修改(行)索引 丶列，或2个都修改。如果仅传入一个序列，则会重新索引行：
In [26]: from pandas import DataFrame In [27]: frame = DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['Ohio','Texas','California']) In [28]: frame Out[28]: Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 In [29]: frame2=frame.reindex(['a','b','c','d']) In [30]: frame2 Out[30]: Ohio Texas California a 0.0 1.0 2.0 b NaN NaN NaN c 3.0 4.0 5.0 d 6.0 7.0 8.0
使用columns关键字可以重新索引列：
In [31]: states=['Texas','Utah','California'] In [32]: frame.reindex(columns=states) Out[32]: Texas Utah California a 1 NaN 2 c 4 NaN 5 d 7 NaN 8
也可以同时对行和列进行重新索引，而插值则只能按行应用：
In [44]: frame.reindex(index=['a','b','c','d'],method='ffill') Out[44]: Ohio Texas California a 0 1 2 b 0 1 2 c 3 4 5 d 6 7 8
In [46]: frame.reindex(index=['a','b','c','d'],method='ffill').reindex(columns=states) Out[46]: Texas Utah California a 1 NaN 2 b 1 NaN 2 c 4 NaN 5 d 7 NaN 8
利用ix的标签索引功能，重新索引任务可以变得更简洁：
In [54]: frame.ix[['a','b','c','d'],states] Out[54]: Texas Utah California a 1.0 NaN 2.0 b NaN NaN NaN c 4.0 NaN 5.0 d 7.0 NaN 8.0
reindex函数的参数：
index：作为索引的新序列。既可以是index实例也可以是其他序列型的python数据结构。index会被完全使用，就像没有任何复制一样。
method：插值(填充)方式，参数(fill丶pad丶bfill丶backfill)
fill_value：在重新索引的过程中，需要引入缺失值使用的任何替代值。
limit：前向或后向填充时的最大填充量。
level：在MultiIndex的指定级别上匹配简单索引，否则选取子集。
copy：默认为True，无论如何都复制；如果为false，则新旧相等就不复制。
丢弃指定轴上的项
丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。由于需要执行一些数据整理和集合逻辑，所以drop方法返回的是一个在指定轴上删除了指定值的新对象：
In [13]: obj=Series(np.arange(5.),index=['a','b','c','d','e']) In [14]: new_obj=obj.drop('c') In [15]: new_obj Out[15]: a 0.0 b 1.0 d 3.0 e 4.0 dtype: float64 In [16]: obj.drop(['d','c']) Out[16]: a 0.0 b 1.0 e 4.0 dtype: float64 In [17]: obj Out[17]: a 0.0 b 1.0 c 2.0 d 3.0 e 4.0 dtype: float64
注意：drop后返回的是一个新的对象，原始的不改变。
对于DataFrame,可以删除任意轴上的索引值：
In [19]: data=DataFrame(np.arange(16).reshape((4,4)),index=['a','b','c','d'],columns=['1','2','3','4']) In [20]: data Out[20]: 1 2 3 4 a 0 1 2 3 b 4 5 6 7 c 8 9 10 11 d 12 13 14 15 In [21]: data.drop(['a','c']) Out[21]: 1 2 3 4 b 4 5 6 7 d 12 13 14 15 In [22]: data.drop('2',axis=1) Out[22]: 1 3 4 a 0 2 3 b 4 6 7 c 8 10 11 d 12 14 15
In [28]: data.drop(['1','3'],axis=1)
Out[28]:
2 4
a 1 3
b 5 7
c 9 11
d 13 15
索引丶选取和过滤
Series索引的工作方式类似于NumPy数组的索引，只不过Series索引值不只是整数。
In [29]: obj=Series(np.arange(5),index=['a','b','c','d','e']) In [30]: obj Out[30]: a 0 b 1 c 2 d 3 e 4 dtype: int32 In [31]: obj['b'] Out[31]: 1 In [32]: obj[1] Out[32]: 1 In [33]: obj[2:4] Out[33]: c 2 d 3 dtype: int32 In [34]: obj[obj<2] Out[34]: a 0 b 1 dtype: int32 In [35]: obj[['a','c','d']] Out[35]: a 0 c 2 d 3 dtype: int32 In [36]: obj[[1,3,4]] Out[36]: b 1 d 3 e 4 dtype: int32
利用标签的切片运算与普通的python切片运算不同，末端是包含的封闭区间。
In [37]: obj[['a','c']] Out[37]: a 0 c 2 dtype: int32
设置的方式也很简单：
In [38]: obj Out[38]: a 0 b 1 c 2 d 3 e 4 dtype: int32 In [39]: obj[['a','c']]=6 In [40]: obj Out[40]: a 6 b 1 c 6 d 3 e 4 dtype: int32
对DataFrame索引就是获取一个或多个列：
In [41]: data Out[41]: 1 2 3 4 a 0 1 2 3 b 4 5 6 7 c 8 9 10 11 d 12 13 14 15 In [42]: data['1'] Out[42]: a 0 b 4 c 8 d 12 Name: 1, dtype: int32 In [43]: data[['1','3']] Out[43]: 1 3 a 0 2 b 4 6 c 8 10 d 12 14
这种索引方式有几个特殊的情况。首先通过切片或布尔型数组选取行：
In [44]: data[:2] Out[44]: 1 2 3 4 a 0 1 2 3 b 4 5 6 7 In [45]: data[data['2']>5] Out[45]: 1 2 3 4 c 8 9 10 11 d 12 13 14 15
另一种用法是通过布尔型DataFrame进行索引：
In [46]: data<5 Out[46]: 1 2 3 4 a True True True True b True False False False c False False False False d False False False False In [47]: data[data<5] Out[47]: 1 2 3 4 a 0.0 1.0 2.0 3.0 b 4.0 NaN NaN NaN c NaN NaN NaN NaN d NaN NaN NaN NaN
这段代码的目的是使DataFrame在语法上更像ndarry。