pandas入门学习

索引对象

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:\python\python36\lib\site-packages\pandas\core\indexes\base.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=['','','',''])

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('',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['']
Out[42]:
a     0
b     4
c     8
d    12
Name: 1, dtype: int32

In [43]: data[['','']]
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['']>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。