基本功能

重新索引

pandas对象的一个重要反复是reindex，其作用是创建一个适应新索引的新对象。

In [136]: obj=Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])

In [137]: obj2=obj.reindex(['a','b','c','d','e'])

In [138]: obj2
Out[138]:
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

如果某个索引值不存在，就引入缺失值

In [140]: obj.reindex(['a','b','c','d','e'],fill_value=0)
Out[140]:
a   -5.3
b    7.2
c    3.6
d    4.5
e    0.0
dtype: float64

对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理，method选项即可达到目的

In [141]: obj3=Series(['blue','purple','yellow'],index=[0,2,4])

In [142]: obj3.reindex(range(6),method='ffill')
Out[142]:
0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

reindex的(插值) method选项

fill或pad：前向填充（或搬运）值

bfill或backfill：后向填充（或搬运）值

对于DataFrame，reindex可以修改（行）索引、列，或2个都修改，如果只传入一个序列，则重新索引行

In [143]: frame=DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['one','two','three'])
     ...:

In [144]: frame
Out[144]:
   one  two  three
a    0    1      2
b    3    4      5
c    6    7      8

In [145]: frame2=frame.reindex(['a','b','c','d'])

In [146]: frame2
Out[146]:
   one  two  three
a  0.0  1.0    2.0
b  3.0  4.0    5.0
c  6.0  7.0    8.0
d  NaN  NaN    NaN

In [147]: states=['red','yellow','green']

In [148]: frame.reindex(columns=states)
Out[148]:
   red  yellow  green
a  NaN     NaN    NaN
b  NaN     NaN    NaN
c  NaN     NaN    NaN

In [149]: states=['red','one','two']

In [150]: frame.reindex(columns=states)
Out[150]:
   red  one  two
a  NaN    0    1
b  NaN    3    4
c  NaN    6    7

也可以同时对行和列进行重新索引，而插值则只能按行应用

In [158]: frame.reindex(index=['a','b','c','d'],method='ffill',columns=['one','two','three'])
Out[158]:
   one  two  three
a    0    1      2
b    3    4      5
c    6    7      8
d    6    7      8

利用ix的标签索引功能，重新索引任务可以变得简洁。

reindex函数的参数：

index：用作索引的新序列。既可以是index实例，也可以是其他序列型的Python数据结构。index会被完全使用，就像没有任何复制一样。

method：插值（填充）方式

fill_value：在重新索引过程中，需要填入缺失值时使用的替代值

limit：前向填充或后向填充的最大填充量

level：在MultiIndex的指定级别上匹配简单索引，否则取其子集

copy：默认为true，无论如何都复制，如果为False，则新旧相等就不复制

 

丢弃指定轴上的项

丢弃某条轴上的一个或多个项很简单，只需要有一个索引数组或列表即可。

In [162]: obj=Series(np.arange(5.),index=['a','b','c','d','e'])

In [163]: new_obj=obj.drop('c')

In [164]: new_obj
Out[164]:
a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64

In [165]: obj
Out[165]:
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
dtype: float64

对于DataFrame，可以任意删除任意轴上的索引值：

In [166]: data=DataFrame(np.arange(16).reshape(4,4),index=['Ohio','Colorado','Utah','New York'],column
     ...: s=['one','two','three','four'])

In [167]: data.drop(['Colorado','Ohio'])
Out[167]:
          one  two  three  four
Utah        8    9     10    11
New York   12   13     14    15

In [170]: data.drop('two',axis=1)
Out[170]:
          one  three  four
Ohio        0      2     3
Colorado    4      6     7
Utah        8     10    11
New York   12     14    15

In [171]: data.drop(['two','four'],axis=1)
Out[171]:
          one  three
Ohio        0      2
Colorado    4      6
Utah        8     10
New York   12     14

索引、选取和过滤

Series索引的工作方式类似于numpy数组的索引，只不过Series的索引值不只是整数

In [173]: obj=Series(np.arange(4.),index=['a','b','c','d'])

In [174]: obj['a']
Out[174]: 0.0

In [175]: obj[1]
Out[175]: 1.0

In [176]: obj[['b','a','d']]
Out[176]:
b    1.0
a    0.0
d    3.0
dtype: float64

In [177]: obj[obj<2]
Out[177]:
a    0.0
b    1.0
dtype: float64

利用标签的切片运算和普通的Python切片运算不同，其末端是包含的：

In [180]: obj['b':'c']
Out[180]:
b    1.0
c    2.0
dtype: float64

In [181]: obj[2:3]
Out[181]:
c    2.0
dtype: float64

设置的方式也很简单：

In [182]: obj['b':'c']=5

In [183]: obj
Out[183]:
a    0.0
b    5.0
c    5.0
d    3.0
dtype: float64

DataFrame进行索引就是获取一个或多个列：

In [184]: data
Out[184]:
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

In [185]: data['one']
Out[185]:
Ohio         0
Colorado     4
Utah         8
New York    12
Name: one, dtype: int32

这种索引方式有几个特殊情况。首先通过切片或布尔型数组进行取行：

In [187]: data[:2]
Out[187]:
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7

In [188]: data[data['three']>5]
Out[188]:
          one  two  three  four
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

另一种是通过布尔型DataFrame进行索引：

In [189]: data<5
Out[189]:
            one    two  three   four
Ohio       True   True   True   True
Colorado   True  False  False  False
Utah      False  False  False  False
New York  False  False  False  False

In [190]: data[data<5]=0

In [191]: data
Out[191]:
          one  two  three  four
Ohio        0    0      0     0
Colorado    0    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

通过索引字段ix选取行和列的子集：

In [197]: data.ix['Colorado',['two','three']]
Out[197]:
two      5
three    6
Name: Colorado, dtype: int32

In [198]: data.ix[data.three>5,:3]

Out[198]:
          one  two  three
Colorado    0    5      6
Utah        8    9     10
New York   12   13     14

DataFrame的索引选项：

类型：说明

obj[val] ： 选取DataFrame的单个列或一组列。在一些特殊情况下会比较便利；布尔型数组、切片、布尔型DataFrame

obj.ix[val]：选取DataFrame的单个行或一组行

obj.ix[:,val]：选取单个列或列子集

obj.ix[val1,val2]：同时选取行和列

reindex方法：将一个或多个轴匹配到新索引

xs方法：根据标签选取单行或单列，并返回一个Series

icol、irow方法：根据整数位置选取单列或单行，并返回一个Series

get_value、set_value方法：根据行标签或列标签选取单个值。

算术运算和数据对齐

pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。

In [7]: s1=Series([7.3,-2.5,3.4,1.5],index=['a','c','d','e'])

In [8]: s2=Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])

In [9]: s1+s2
Out[9]:
a    5.2
c    1.1
d    NaN
e    0.0
f    NaN
g    NaN
dtype: float64

自动的数据对齐操作不重叠的索引处引入了NA值。缺失值会在算术运算中传播。

对于DataFrame，对齐操作会同时发生在行和列上：

In [15]: df1=DataFrame(np.arange(9).reshape(3,3),columns=list('bcd'),index=['one','two','three'])

In [16]: df2=DataFrame(np.arange(12).reshape(4,3),columns=list('bde'),index=['one','two','three','four'])

In [17]: df1+df2
Out[17]:
          b   c     d   e
four    NaN NaN   NaN NaN
one     0.0 NaN   3.0 NaN
three  12.0 NaN  15.0 NaN
two     6.0 NaN   9.0 NaN

在算术方法中填充值

在对不同的索引对象进行算术运算时，可能希望当一个对象中某个轴标签在另一个对象中找不到时，填充一个特殊值：

In [18]: df1=DataFrame(np.arange(12).reshape(3,4),columns=list('abcd'))

In [19]: df2=DataFrame(np.arange(20).reshape(4,5),columns=list('abcde'))

In [20]: df1+df2
Out[20]:
      a     b     c     d   e
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN

使用df1的add方法，传入df2以及一个fill_value参数：

In [21]: df1.add(df2,fill_value=0)
Out[21]:
      a     b     c     d     e
0   0.0   2.0   4.0   6.0   4.0
1   9.0  11.0  13.0  15.0   9.0
2  18.0  20.0  22.0  24.0  14.0
3  15.0  16.0  17.0  18.0  19.0

与此类似，在对Series或DataFrame重新索引时，也可以指定一个填充值：

In [22]: df1.reindex(columns=df2.columns,fill_value=0)
Out[22]:
   a  b   c   d  e
0  0  1   2   3  0
1  4  5   6   7  0
2  8  9  10  11  0

算术方法：add（加法）、sub（减法）、div（除法）、mul（乘法）

DataFrame和Series之间的运算

跟numpy数组一样，DataFrame和Series之间的算术运算也是有明确规定的

In [23]: arr=np.arange(12).reshape(3,4)

In [24]: arr
Out[24]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [25]: arr[0]
Out[25]: array([0, 1, 2, 3])

In [26]: arr-arr[0]
Out[26]:
array([[0, 0, 0, 0],
       [4, 4, 4, 4],
       [8, 8, 8, 8]])

这就叫广播。DataFrame和Series之间的运算也是如此。

In [27]: frame=DataFrame(np.arange(12).reshape(4,3),columns=list('bde'),index=['one','two','three','four'])

In [28]: series=frame.ix[0]

In [29]: frame
Out[29]:
       b   d   e
one    0   1   2
two    3   4   5
three  6   7   8
four   9  10  11

In [30]: series
Out[30]:
b    0
d    1
e    2
Name: one, dtype: int32

默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播：

In [31]: frame-series
Out[31]:
       b  d  e
one    0  0  0
two    3  3  3
three  6  6  6
four   9  9  9

如果某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被重新索引以形成并集：

In [32]: series2=Series(range(3),index=['b','e','f'])

In [33]: frame+series2
Out[33]:
         b   d     e   f
one    0.0 NaN   3.0 NaN
two    3.0 NaN   6.0 NaN
three  6.0 NaN   9.0 NaN
four   9.0 NaN  12.0 NaN

如果希望匹配行且在列上广播，那么必须使用算术运算方法：

In [34]: series3=frame['d']

In [35]: frame
Out[35]:
       b   d   e
one    0   1   2
two    3   4   5
three  6   7   8
four   9  10  11

In [36]: series3
Out[36]:
one       1
two       4
three     7
four     10
Name: d, dtype: int32

In [37]: frame.sub(series3,axis=0)
Out[37]:
       b  d  e
one   -1  0  1
two   -1  0  1
three -1  0  1
four  -1  0  1

函数应用和映射

numpy的ufunc（元素级数组方法）也可以用于操作pandas对象

In [40]: frame=DataFrame(np.random.randn(4,3),columns=list('bde'),index=['one','two','three','four'])

In [41]: frame
Out[41]:
              b         d         e
one    0.341012  0.864333  0.228682
two   -0.838441  0.483385  1.747057
three  0.479806 -2.392724  0.385935
four   0.602425 -0.150350 -0.072265

In [42]: np.abs(frame)
Out[42]:
              b         d         e
one    0.341012  0.864333  0.228682
two    0.838441  0.483385  1.747057
three  0.479806  2.392724  0.385935
four   0.602425  0.150350  0.072265

In [43]: np.sum(frame)
Out[43]:
b    0.584803
d   -1.195355
e    2.289409
dtype: float64

另一个常见的操作是，将行数应用到各行或各列所形成的一维数组上。DataFrame的apply方法可以实现功能

In [44]: f=lambda x:x.max() - x.min()

In [45]: frame.apply(f)
Out[45]:
b    1.440866
d    3.257057
e    1.819322
dtype: float64

In [46]: frame.apply(f,axis=1)
Out[46]:
one      0.635651
two      2.585498
three    2.872530
four     0.752775
dtype: float64

许多常见的数组统计功能都被实现成DataFrame的方法，因此无需apply方法。

除了标量值外，传递给apply的函数还可以返回由多个值组成的series：

In [49]: def f(x):
    ...:     return Series([x.min(),x.max()],index=['min','max'])
    ...:
    ...:

In [50]: frame.apply(f)
Out[50]:
            b         d         e
min -0.838441 -2.392724 -0.072265
max  0.602425  0.864333  1.747057

排序和排名

根据条件对数据集排序也是一种重要的内置运算。要对行或列索引进行排序，可使用sort_index方法，它返回一个已排序的新对象：

In [51]: obj=Series(range(4),index=list('dabc'))

In [52]: obj.sort_index()
Out[52]:
a    1
b    2
c    3
d    0
dtype: int64

而对于DataFrame，则可以根据任意一个轴上的索引进行排序：

In [54]: frame
Out[54]:
              b         d         e
one    0.341012  0.864333  0.228682
two   -0.838441  0.483385  1.747057
three  0.479806 -2.392724  0.385935
four   0.602425 -0.150350 -0.072265

In [55]: frame.sort_index()
Out[55]:
              b         d         e
four   0.602425 -0.150350 -0.072265
one    0.341012  0.864333  0.228682
three  0.479806 -2.392724  0.385935
two   -0.838441  0.483385  1.747057

In [56]: frame.sort_index(axis=1)
Out[56]:
              b         d         e
one    0.341012  0.864333  0.228682
two   -0.838441  0.483385  1.747057
three  0.479806 -2.392724  0.385935
four   0.602425 -0.150350 -0.072265

数据默认是按升序排序的，也可以按照降序排序：

In [57]: frame.sort_index(axis=1,ascending=False)
Out[57]:
              e         d         b
one    0.228682  0.864333  0.341012
two    1.747057  0.483385 -0.838441
three  0.385935 -2.392724  0.479806
four  -0.072265 -0.150350  0.602425

在DataFrame上，如果需要根据一个或多个列中的值进行排序，将一个或多个列的名字传递给by选项即可：

In [71]: frame=DataFrame({'b':[4,7,-2,3],'a':[0,1,0,1]})

In [72]: frame
Out[72]:
   b  a
0  4  0
1  7  1
2 -2  0
3  3  1

In [73]: frame.sort_values(by='a')
Out[73]:
   b  a
0  4  0
2 -2  0
1  7  1
3  3  1

In [77]: frame.sort_index(by=['a','b'])
Out[77]:
   b  a
2 -2  0
0  4  0
3  3  1
1  7  1

排名跟排序关系密切，且它会增设一个排名值（从1开始，一直到数组中有效数据的数量）。它跟numpy.argsort产生的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系，那就是rank方法。

rank方法是通过”为各组分配一个平均排名“的方式破坏平级关系：

In [78]: obj=Series([7,-5,7,4,2,0,4])

In [79]: obj.rank()
Out[79]:
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

也可以根据值在源数据中出现的顺序给出排名：

In [80]: obj.rank(method='first')
Out[80]:
0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64

也可以按照降序排名：

In [81]: obj.rank(method='max',ascending=False)
Out[81]:
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64

排名用于破坏平级关系的method选项：

average：默认：在相等分组中，为各个值分配平均排名

min：使用整个分组的最小排名

max：使用整个分组最大排名

first：按值在原始数据中出现的顺序分配排名

带有重复值的轴索引

虽然很多pandas函数都要求标签唯一，但不是强制性的：

In [85]: obj=Series(range(5),index=list('aabbc'))

In [86]: obj
Out[86]:
a    0
a    1
b    2
b    3
c    4
dtype: int64

索引的is_unique属性可以告诉你它的值是否唯一

In [87]: obj.index.is_unique
Out[87]: False

对带有重复值的索引，数据选取的行为将会有些不同。如果某个索引对应多个值，则返回一个Series，而对应单个值得，则返回一个标量：

In [88]: obj['a']
Out[88]:
a    0
a    1
dtype: int64

In [89]: obj['c']
Out[89]: 4

对DataFrame的行进行索引时也是如此：

In [94]: df=DataFrame(np.arange(12).reshape(4,3),index=list('aabb'))

In [95]: df.ix['b']
Out[95]:
   0   1   2
b  6   7   8
b  9  10  11

In [96]: df
Out[96]:
   0   1   2
a  0   1   2
a  3   4   5
b  6   7   8
b  9  10  11