Python数据分析06：Pandas基本功能

CHAPTER 5

Getting Started with pandas

---

---

5.2 基本功能（Essential Functionality）

下面我们来从Series和DataFrame中的数据入手，看看pandas最重要也最基础的内容。

5.2.1 重新索引（Reindexing）

pandas中一个重要的方法是reindex，用来在创建object的时候遵照一个新的index。如下例：

>>>import pandas as pd
>>>obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
>>>obj
d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

5.2.1.1 reindex函数

在series上调用reindex能更改index，如果没有对应index的话会引入缺失数据：

>>>obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
>>>obj2
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

在处理时间序列这样的数据时，我们可能需要在reindexing的时候需要修改值。method选项能做到这一点，比如设定method为ffill:

>>>obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
>>>obj3
0      bule
2    purple
4    yellow
dtype: object
>>>obj3.reindex(range(6), method='ffill')
0      bule
1      bule
2    purple
3    purple
4    yellow
5    yellow
dtype: object

5.2.1.2 reindex函数各参数说明

参数	说明
index	用作索引的新序列，既可以是Index实例，也可是其他序列型的Python数据对象
method	插值（填充）方式，具体见下表
fill_value	在需要重新索引的过程中，引入缺失值时使用的代替值
limit	向前或向后填充时的最大填充量
tolerance	向前向后填充时，填充不准确匹配项的最大间距（绝对值距离）
level	在MultiIndex的指定级别上匹配简单索引
copy	默认为True，无论如何都复制；如果为False，则新旧相同就不复制

5.2.1.3 更改DataFrame行列索引

对于DataFrame，reindex能更改row index,或column index。

更改行：

>>>import numpy as np
>>>frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
>>>                     index=['a', 'c', 'd'],
>>>                     columns=['Ohio', 'Texas', 'California'])
>>>frame
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8
>>>frame2 = frame.reindex(['a', 'b', 'c', 'd'])
>>>frame2
   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

更改列：

>>>states = ['Texas', 'Utah', 'California']
>>>frame.reindex(columns=states)
   Texas  Utah  California
a      1   NaN           2
c      4   NaN           5
d      7   NaN           8

还可以使用loc——更简洁的reindex：

>>>frame.loc[['a', 'b', 'c', 'd'], states]
   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

5.2.2 丢弃指定轴上的项（Dropping Entries from an Axis）

5.2.2.1 drop函数

• 对于series，drop会返回一个新的object，并删去你指定的axis的值：

>>>obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
>>>obj
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
dtype: float64
>>>new_obj = obj.drop('c')
>>>new_obj
a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64
>>>obj.drop(['d', 'c'])
a    0.0
b    1.0
e    4.0
dtype: float64

• 对于DataFrame，可以drop任意轴上的索引值：

>>>data = pd.DataFrame(np.arange(16).reshape((4, 4)),
>>>                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
>>>                    columns=['one', 'two', 'three', 'four'])
>>>data
          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

行处理：如果用a sequence of labels(一个标签序列)来调用drop，会删去row labels删除值:

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

列处理：drop列的话，设定axis=1或axis=‘columns’：

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

drop也可以不返回一个新的object，而是直接更改series或dataframe：

>>>obj.drop('c', inplace=True)
>>>obj
a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64

5.2.3 索引，选取，过滤（Indexing, Selection, and Filtering）

5.2.3.1 Series的索引

series indexing(obj[…]) 相当于numpy的array indexing, 而且除了整数，还可以使用series的index：

>>>obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
>>>obj
a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
>>>obj['b']
1.0
>>>obj[1]
1.0
>>>obj[2:4]
c    2.0
d    3.0
dtype: float64
>>>obj[['b', 'a', 'd']]
b    1.0
a    0.0
d    3.0
dtype: float64
>>>obj[[1, 3]]
b    1.0
d    3.0
dtype: float64
>>>obj[obj < 2]
a    0.0
b    1.0
dtype: float64

用label来slicing(切片)的时候，和python的切片不一样的在于会包括尾节点：

>>>obj['b':'c']
b    1.0
c    2.0
dtype: float64

直接给选中的label更改值：

>>>obj['b':'c'] = 5
>>>obj
a    0.0
b    5.0
c    5.0
d    3.0
dtype: float64

5.2.3.2 DataFrame的索引

• 通过一个值或序列，对DataFrame索引：

>>>data = pd.DataFrame(np.arange(16).reshape((4, 4)),
>>>                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
>>>                    columns=['one', 'two', 'three', 'four'])
>>>data
          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
>>>data['two']
Ohio         1
Colorado     5
Utah         9
New York    13
Name: two, dtype: int32
>>>data[['three', 'one']]
          three  one
Ohio          2    0
Colorado      6    4
Utah         10    8
New York     14   12

• 通过布尔数组对DataFrame进行索引：

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

行选择的语法格式data[:2]是很方便的。给[]里传入一个list的话，可以选择列。

• 通过布尔型DataFrame（由标量比较运算得出）进行索引:

>>>data < 5
            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
>>>data[data < 5] = 0
>>>data
          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

5.2.3.3 用loc和iloc进行选取

对于DataFrame的行标签索引，loc和iloc比较特殊。这两个方法能通过axis labels(loc)或integer(iloc)来选择行或列。

栗子，选中一行多列by label：

>>>data.loc['Colorado', ['two', 'three']]
two      5
three    6
Name: Colorado, dtype: int32

用iloc实现相同的效果：

>>>data.iloc[2, [3, 0, 1]]
four    11
one      8
two      9
Name: Utah, dtype: int32
>>>data.iloc[2]
one       8
two       9
three    10
four     11
Name: Utah, dtype: int32
>>>data.iloc[[1, 2], [3, 0, 1]]
          four  one  two
Colorado     7    0    5
Utah        11    8    9

这两个索引函数也适用于⼀个标签或多个标签的切片：

>>>data.loc[:'Utah', 'two']
Ohio        0
Colorado    5
Utah        9
Name: two, dtype: int32
>>>data.iloc[:, :3][data.three > 5]
          one  two  three
Colorado    0    5      6
Utah        8    9     10
New York   12   13     14

5.2.3.4 DataFrame的索引选项

类型	说明
df[val]	从DataFrame选取单列或列子集；布尔型数组（过滤行）、切片（切片行） 或布尔型DataFrame（根据条件设置值）
df.loc[val]	通过标签，选取DataFrame的单个行或行子集
df.loc[:, val]	通过标签，选组单列或列子集
df.loc[val1, val2]	通过标签，同时选取行和列
df.iloc[where]	通过整数位置，从DataFrame选取单个行或行子集
df.iloc[:, where]	通过整数位置，从DataFrame选取单个列或列子集
df.iloc[where_i, where_j]	通过整数位置，同时选取行和列
df.at[label_i, label_j]	通过行和列标签，选取单一的标量
df.iat[i, j]	通过行和列实务位置（整数），选取单一的标量
reindex method	通过标签选取行和列
get_value, set_value methods	通过行和列标签选取单一值

5.2.4 整数索引（Integer Indexes）

一些新手再用integer来index的时候，总是会出错。因为这种方法和python用于list和tuple的indexing方法不同。

比如，你不希望下面的代码出现error：

>>>ser = pd.Series(np.arange(3.))
>>>ser
0    0.0
1    1.0
2    2.0
dtype: float64
>>>ser[-1]
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-58-44969a759c20> in <module>
----> 1 ser[-1]
"...省略..."
KeyError: -1

pandas在整数索引上可能会出错，另一方面，如果用非整数来做index，就没有歧义了：

>>>ser2 = pd.Series(np.arange(3.), index=['a', 'b', 'c'])
>>>ser2[-1]
2.0

为了保持连贯性，如果axis index里包含integer，那么选择数据的时候，就会使用标签。为了更精确地选择，使用loc(for label)或ilco(for integers):

>>>ser[:1]
0    0.0
dtype: float64
>>>ser.loc[:1]
0    0.0
1    1.0
dtype: float64
>>>ser.iloc[:1]
0    0.0
dtype: float64

5.2.5 算术运算和数据对齐（Arithmetic and Data Alignment）

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

>>>s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
>>>s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],
>>>               index=['a', 'c', 'e', 'f', 'g'])
>>>s1
a    7.3
c   -2.5
d    3.4
e    1.5
dtype: float64
>>>s2
a    2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64
>>>s1 + s2
a    9.4
c    1.1
d    NaN
e    0.0
f    NaN
g    NaN
dtype: float64

这种数据对齐的方式（internal data alignment）引入了很多缺失值，这些缺失值会被用在之后的算数计算中。

在DataFrame中，数据对齐同时发生在行和列上：

>>>df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
>>>                   index=['Ohio', 'Texas', 'Colorado'])
>>>df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
>>>                   index=['Utah', 'Ohio', 'Texas', 'Oregon'])
>>>df1
            b    c    d
Ohio      0.0  1.0  2.0
Texas     3.0  4.0  5.0
Colorado  6.0  7.0  8.0
>>>df2
          b     d     e
Utah    0.0   1.0   2.0
Ohio    3.0   4.0   5.0
Texas   6.0   7.0   8.0
Oregon  9.0  10.0  11.0

相加的结果就是两个DataFrame，行和列的合集：

>>>df1 + df2
            b   c     d   e
Colorado  NaN NaN   NaN NaN
Ohio      3.0 NaN   6.0 NaN
Oregon    NaN NaN   NaN NaN
Texas     9.0 NaN  12.0 NaN
Utah      NaN NaN   NaN NaN

因为’c’和’e’列都不同时在两个DataFrame里，所有全是缺失值。对于行，即使有相同的，但列不一样的话也会是缺失值。

如果两个DataFrame相加，而且没有column和row，结果会全是null：

>>>df1 = pd.DataFrame({'A': [1, 2]})
>>>df2 = pd.DataFrame({'B': [3, 4]})
>>>df1
   A
0  1
1  2
>>>df2
   B
0  3
1  4
>>>df1 - df2
    A   B
0 NaN NaN
1 NaN NaN

5.2.5.1 带填充值的算数方法

对于上面那些缺失值，我们想要填上0：

>>>df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),
>>>                   columns=list('abcd'))
>>>df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),
>>>                   columns=list('abcde'))
>>>df2.loc[1, 'b'] = np.nan
>>>df1
     a    b     c     d
0  0.0  1.0   2.0   3.0
1  4.0  5.0   6.0   7.0
2  8.0  9.0  10.0  11.0
>>>df2
      a     b     c     d     e
0   0.0   1.0   2.0   3.0   4.0
1   5.0   NaN   7.0   8.0   9.0
2  10.0  11.0  12.0  13.0  14.0
3  15.0  16.0  17.0  18.0  19.0

不填充的结果：

>>>df1 + df2
      a     b     c     d   e
0   0.0   2.0   4.0   6.0 NaN
1   9.0   NaN  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN

使用参数fill_value进行填充：

>>>df1.add(df2, fill_value=0)
      a     b     c     d     e
0   0.0   2.0   4.0   6.0   4.0
1   9.0   5.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

算术方法：除法运算

>>>1 / df1
       a         b         c         d
0    inf  1.000000  0.500000  0.333333
1  0.250  0.200000  0.166667  0.142857
2  0.125  0.111111  0.100000  0.090909
>>>df1.rdiv(1)
       a         b         c         d
0    inf  1.000000  0.500000  0.333333
1  0.250  0.200000  0.166667  0.142857
2  0.125  0.111111  0.100000  0.090909

在reindex（重建索引）的时候，也可以使用fill_value:

>>>df1.reindex(columns=df2.columns, fill_value=0)
     a    b     c     d  e
0  0.0  1.0   2.0   3.0  0
1  4.0  5.0   6.0   7.0  0
2  8.0  9.0  10.0  11.0  0

5.2.5.2 Series和DataFrame的算术方法

方法	说明
add, radd	用于加法(+)的方法
sub, rsub	用于减法(-)的方法
div, rdiv	用于除法(/)的方法
floordiv, rfloordiv	用于底除(//)的方法
mul, rmul	用于乘法(*)的方法
pow, rpow	用于指数(**)的方法

5.2.5.3 DataFrame和Series之间的运算

先来看⼀个栗子，计算⼀个⼆维数组与其某行之间的差：

>>>arr = np.arange(12.).reshape((3, 4))
>>>arr
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]])
>>>arr[0]
array([0., 1., 2., 3.])
>>>arr - arr[0]
array([[0., 0., 0., 0.],
       [4., 4., 4., 4.],
       [8., 8., 8., 8.]])

可以看到，这个减法是用在了每一行上。这种操作叫broadcasting，在Appendix A有更详细的解释。DataFrame和Series的操作也类似：

>>>frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
>>>                     columns=list('bde'),
>>>                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
>>>series = frame.iloc[0]
>>>frame
          b     d     e
Utah    0.0   1.0   2.0
Ohio    3.0   4.0   5.0
Texas   6.0   7.0   8.0
Oregon  9.0  10.0  11.0
>>>series
b    0.0
d    1.0
e    2.0
Name: Utah, dtype: float64

可以理解为series的index与dataframe的列匹配，broadcasting down the rows(向下按行广播):

>>>frame - series
          b    d    e
Utah    0.0  0.0  0.0
Ohio    3.0  3.0  3.0
Texas   6.0  6.0  6.0
Oregon  9.0  9.0  9.0

如果一个index既不在DataFrame的column中，也不再Series里的index中，那么结果也是合集：

>>>series2 = pd.Series(range(3), index=['b', 'e', 'f'])
>>>frame + series2
          b   d     e   f
Utah    0.0 NaN   3.0 NaN
Ohio    3.0 NaN   6.0 NaN
Texas   6.0 NaN   9.0 NaN
Oregon  9.0 NaN  12.0 NaN

如果想要在列上广播，去匹配行，必须要用到算数方法：

>>>series3 = frame['d']
>>>frame
          b     d     e
Utah    0.0   1.0   2.0
Ohio    3.0   4.0   5.0
Texas   6.0   7.0   8.0
Oregon  9.0  10.0  11.0
>>>series3
Utah       1.0
Ohio       4.0
Texas      7.0
Oregon    10.0
Name: d, dtype: float64
>>>frame.sub(series3, axis='index')  #减法算术运算，见上表
Out[53]: 
          b    d    e
Utah   -1.0  0.0  1.0
Ohio   -1.0  0.0  1.0
Texas  -1.0  0.0  1.0
Oregon -1.0  0.0  1.0

axis参数就是用来匹配轴的。在这个例子里是匹配dataframe的row index(axis='index or axis=0)，然后再广播。

5.2.6 函数应用和映射（Function Application and Mapping）

numpy的ufuncs(element-wise数组方法)也能用在pandas的object上：

>>>frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
>>>                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
>>>frame
               b         d         e
Utah    0.392567  0.271998  0.790944
Ohio    0.788808  1.909102  0.039790
Texas   0.511341  1.029418  0.081864
Oregon  1.189705  0.692081  0.834665
>>>np.abs(frame)
               b         d         e
Utah    1.282098  1.229175  0.732095
Ohio    0.950254  1.295434  1.679189
Texas   0.874102  1.274932  0.844413
Oregon  0.914953  2.101899  0.613982

5.2.6.1 apply函数

另⼀个常见的操作是，将函数应用到由各列或行所形成的⼀维数组上。DataFrame的apply函数即可实现此功能：

>>>f = lambda x: x.max() - x.min()
>>>frame.apply(f)
b    2.232352
d    3.397333
e    2.523603
dtype: float64

这里函数f，是计算series中最大值和最小值的差，frame中有几列，这个函数就被调用几次。作为结果的series，它的index就是frame的column。

如果你传入axis='column'用于apply，那么函数会被用在每一行：

>>>frame.apply(f, axis='columns')
Utah      2.725222
Ohio      1.672987
Texas     1.896290
Oregon    1.308482
dtype: float64

像是sum, mean这样的数组统计方法，DataFrame中已经集成了，所以没必要用apply。

apply不会返回标量，只会返回一个含有多个值的series：

>>>def f(x):
>>>    return pd.Series([x.min(), x.max()], index=['min', 'max'])
>>>frame.apply(f)
            b         d         e
min -0.950254 -1.295434 -1.679189
max  1.282098  2.101899  0.844413

element-wise的python函数也能用。假设想要格式化frame中的浮点数，变为string。可以用applymap：

>>>format = lambda x: '%.2f' % x
>>>frame.applymap(format)
            b      d      e
Utah     1.28   1.23  -0.73
Ohio    -0.95  -1.30  -1.68
Texas   -0.87   1.27   0.84
Oregon  -0.91   2.10   0.61

applymap的做法是，series有一个map函数，能用来实现element-wise函数：

>>>frame['e'].map(format)
Utah       1.63
Ohio       1.28
Texas     -1.20
Oregon     0.09
Name: e, dtype: object

5.2.7 排序和排名（Sorting and Ranking）

5.2.7.1 排序

• sort_index函数

按row或column的索引来排序的话，可以用sort_index函数，会返回一个新的object：

>>>obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
>>>obj.sort_index()
a    1
b    2
c    3
d    0
dtype: int64

在DataFrame，可以用index或其他axis来排序：

>>>frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
>>>                     index=['three', 'one'],
>>>                     columns=['d', 'a', 'b', 'c'])
>>>frame
       d  a  b  c
three  0  1  2  3
one    4  5  6  7
>>>frame.sort_index()
       d  a  b  c
one    4  5  6  7
three  0  1  2  3
>>>frame.sort_index(axis=1)
       a  b  c  d
three  1  2  3  0
one    5  6  7  4

默认是升序，可以设置降序：

>>>frame.sort_index(axis=1, ascending=False)
       d  c  b  a
three  0  3  2  1
one    4  7  6  5

• sort_values函数

通过值来排序，用sort_values函数：

>>>obj = pd.Series([4, 7, -3, 2])
>>>obj.sort_values()
2   -3
3    2
0    4
1    7
dtype: int64

若存在缺失值，则缺失值会被排在最后：

>>>obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
>>>obj.sort_values()
4   -3.0
5    2.0
0    4.0
2    7.0
1    NaN
3    NaN
dtype: float64

对于一个DataFrame，可以用一列或多列作为排序keys。这样的话，只需要把一列或多列的名字导入到sort_values即可：

>>>frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
>>>frame
   b  a
0  4  0
1  7  1
2 -3  0
3  2  1
>>>frame.sort_values(by='b')
   b  a
2 -3  0
3  2  1
0  4  0
1  7  1

多列排序需要传入一个list：

>>>frame.sort_values(by=['a', 'b'])
   b  a
2 -3  0
0  4  0
3  2  1
1  7  1

5.2.7.2 排名

• rank函数

平均排名（存在相同值时出现）

ranking（排名）是给有效的数据分配数字。rank函数能用于series和DataFrame，rank函数默认会给每个group一个mean rank（平均排名）。rank表示在这个数在原来的Series中排第几名，有相同的数，取其排名平均（默认）作为值：

>>>obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
>>>obj
0    7
1   -5
2    7
3    4
4    2
5    0
6    4
dtype: int64
>>>obj.sort_values()  #给值排序
1   -5
5    0
4    2
3    4
6    4
0    7
2    7
dtype: int64
>>>obj.rank()
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

解释一下先，在obj中，4和4的排名是第4名和第五名，取平均得4.5。7和7的排名分别是第六名和第七名，则其排名取平均得6.5。

顺序排名（我自己起的名字哈）

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

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

这里没有给0和2(指两个数字7)赋予average rank 6.5，而是给第一个看到的7（label 0）设置rank为6，第二个看到的7（label 2）设置rank为7。

也可以设置降序：

>>># Assign tie values the maximum rank in the group
>>>obj.rank(ascending=False, method='max')
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64

DataFrame可以根据行或列来计算rank:

>>>frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
>>>                      'c': [-2, 5, 8, -2.5]})
>>>frame
     b  a    c
0  4.3  0 -2.0
1  7.0  1  5.0
2 -3.0  0  8.0
3  2.0  1 -2.5
>>>frame.rank(axis='columns')  #"columns"表示列与列之间的排序（即每一行里数据间的排序）
     b    a    c
0  3.0  2.0  1.0
1  3.0  1.0  2.0
2  1.0  2.0  3.0
3  3.0  2.0  1.0

5.2.7.3 排名时用于破坏平级关系的方法

method	描述
‘average’	默认值，将平均排名分配给组中的每个对象
‘min’	是用整个分组的最小排名
‘max’	是用整个分组的最大排名
‘first’	按值在原始数据中出现的顺序分配排名
‘dense’	类似于’min’方法，但是排名总是在组间增加1，而不是组中相同的元素数

5.2.8 带有重复标签的轴索引（Axis Indexes with Duplicate Labels）

我们看到的所有例子都有唯一的轴标签（索引值）。一些pandas函数（reindex），需要label是唯一的，但这并不是强制性的。比如下面有一个重复的索引：

>>>obj = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
>>>obj
a    0
a    1
b    2
b    3
c    4
dtype: int64

index的is_unique特性能告诉我们label是否是唯一的：

>>>obj.index.is_unique
False

数据选择对于重复label则表现有点不同。如果一个label有多个值，那么就会返回一个series, 如果是label只对应一个值的话，会返回一个标量：

>>>obj['a']
a    0
a    1
dtype: int64
>>>obj['c']
4

这个选择的逻辑也适用于DataFrame：

>>>df = pd.DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
>>>df
          0         1         2
a  0.862580 -0.010032  0.050009
a  0.670216  0.852965 -0.955869
b -0.023493 -2.304234 -0.652469
b -1.218302 -1.332610  1.074623
>>>df.loc['b']
          0         1         2
b -0.023493 -2.304234 -0.652469
b -1.218302 -1.332610  1.074623

---

参考资料：

• 利用Python进行数据分析学习笔记（有惊喜^_^）
• 书籍：《Python for Data Analysis》