In [43]: frame2['state']    In [44]: frame2.year
one   Ohio                  one   2000
two   Ohio                  two   2001
three Ohio                  three 2002
four  Nevada                four  2001
five  Nevada                five  2002
Name: state                 Name: year

In [45]: frame2.ix['three']
year   2002
state  Ohio
pop    3.6
debt   NaN
Name: three

In [26]: df.loc[dates[0]]
A    0.469112
B   -0.282863
C   -1.509059
D   -1.135632
Name: 2013-01-01 00:00:00, dtype: float64

In [27]: df.loc[:,['A','B']]
                   A         B
2013-01-01  0.469112 -0.282863
2013-01-02  1.212112 -0.173215
2013-01-03 -0.861849 -2.104569
2013-01-04  0.721555 -0.706771
2013-01-05 -0.424972  0.567020
2013-01-06 -0.673690  0.113648

In [31]: df.at[dates[0],'A']
Out[31]: 0.46911229990718628

In [39]: df[df.A > 0]
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-04  0.721555 -0.706771 -1.039575  0.271860

In [40]: df[df > 0]
                   A         B         C         D
2013-01-01  0.469112       NaN       NaN       NaN
...

In [41]: df2 = df.copy()
In [42]: df2['E'] = ['one', 'one','two','three','four','three']
In [43]: df2
                   A         B         C         D      E
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632    one
2013-01-02  1.212112 -0.173215  0.119209 -1.044236    one
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804    two
2013-01-04  0.721555 -0.706771 -1.039575  0.271860  three
2013-01-05 -0.424972  0.567020  0.276232 -1.087401   four
2013-01-06 -0.673690  0.113648 -1.478427  0.524988  threeIn [44]: df2[df2['E'].isin(['two','four'])]
Out[44]:
                   A         B         C         D     E
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804   two
2013-01-05 -0.424972  0.567020  0.276232 -1.087401  four

索引，挑选和过滤

Series索引和整数索引

Series索引( obj[...] )的工作原理类似与NumPy索引，除了可以使用Series的索引值，也可以仅使用整数索引。

In [102]: obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
In [103]: obj['b']     In [104]: obj[1]
Out[103]: 1.0          Out[104]: 1.0
In [105]: obj[2:4]     In [106]: obj[['b', 'a', 'd']]
Out[105]:              Out[106]:
c   2                  b    1
d   3                  a    0
d   3In [107]: obj[[1, 3]]      In [108]: obj[obj < 2]
b   1                      a    0
d   3                      b    1

整数索引
操作由整数索引的pandas对象跟内置的Python数据结构 (如列表和元组)在索引语义上有些不同。
例如，你可能认为下面这段代码不会产生一个错误：
ser = pd.Series(np.arange(3.))
ser
Out[11]: 
0    0.0
1    1.0
2    2.0
dtype: float64
ser[-1]
这里，有一个含有0,1,2的索引，很难推断出用户想要什么(基于标签或位置的索引);相反，一个非整数索引，就没有这样的歧义：
>>>ser2 = pd.Series(np.arange(3.), index=['a', 'b', 'c'])
>>>ser2[-1]
2.0
为了保持良好的一致性，如果轴索引含有索引器，那么根据整数进行数据选取的操作将总是面向标签的。这也包括用ix进行切片：
ser.ix[:1]
Out[15]: 
0    0.0
1    1.0
dtype: float64

Series的iget_ value 方法、DataFrame 的 irow 和 icol 方法

如果你需要可靠的、不考虑索引类型的、基于位置的索引，可以使用Series的iget_ value 方法和 DataFrame 的 irow 和 icol 方法：
>>> ser3 = pd.Series(range(3), index=[-5, 1, 3])
>>> ser3.iget_value(2)
2
>>> frame = pd.DataFrame(np.arange(6).reshape(3, 2), index=[2,0,1])
frame
Out[21]: 
   0  1
2  0  1
0  2  3
1  4  5
>>> frame.irow(0)
0    0
1    1
Name: 2, dtype: int32

标签切片

使用标签来切片和正常的Python切片并不一样，它会把结束点也包括在内：

In [109]: obj['b':'c']
b   1
c   2

索引赋值

使用这些函数来赋值

In [110]: obj['b':'c'] = 5
In [111]: obj
a   0
b   5
c   5
d   3

通过切片或一个布尔数组来选择行，这旨在在这种情况下使得DataFrame的语法更像一个ndarry。

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

DataFrame行标签索引 ix

DataFrame可以在行上进行标签索引，使你可以从DataFrame选择一个行和列的子集，使用像NumPy的记法再加上轴标签。这也是一种不是很冗长的重新索引的方法：

因此，有很多方法来选择和重排包含在pandas对象中的数据。

DataFrame方法的简短概要

还有分层索引及一些额外的选项。

Note:在设计pandas时，我觉得不得不敲下 frame[:, col] 来选择一列，是非常冗余的（且易出错的），因此列选择是最常见的操作之一。因此，我做了这个设计权衡，把所有的富标签索引引入到ix 。

[Different Choices for Indexing]

唯一值、值计数以及成员资格

唯一值、值计数、成员资格方法

方法                          说明
isin                 计算一个表示“Series各值是否包含于传入的值序列中”的布尔型数组 
unique            计算Series中的唯一值数组，按发现的顺序返回 
value_counts    返回一个Series,其索引为唯一值，其值为频率，按计数值降序排列
这类方法可以从一维Series的值中抽取信息。

isin

用于判断矢量化集合的成员资格，可用于选取Series中或DataFrame列中 数据的子集：
>>> obj
0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object
>>>mask=obj.isin(['b','c'])
>>> mask
0     True...
8     True
dtype: bool
>>> obj[mask]
0    c
5    b
6    b
7    c
8    c

>>> obj=Series(['c','a','d','a','a','b','b','c','c'])

obj.unique()

# 函数是unique，它可以得到Series中的唯一值数组：
>>>uniques = obj.unique()
>>>uniques
array(['c', 'a', 'd', 'b'], dtype=object)
返冋的唯一值是未排序的，如果需要的话，可以对结果再次进行排序(uniques. sort())。

value_counts

用于计算一个Series中各值出现的频率：
>>> obj.value_counts()
c    3
a    3
b    2
d    1
dtype: int64
为了便于査看，结果Series是按值频率降序排列的。

查源码，发现这个统计是通过hashtable实现的。keys, counts = htable.value_count_scalar64(values, dropna)

统计数组或序列所有元素出现次数pd.value_counts

value_counts还是一个顶级pandas方法，可用于任何数组或序列： 
>>> pd.value_counts(obj.values, sort=False)
a    3
c    3
b    2
d    1
dtype: int64

返回一个pandas.series对象，不过你基本可以将它当成dict一样使用。

当然也可以减去一些判断，直接使用pandas.value_counts()调用的hashtable统计方法（lz在源码中看到的）

import pandas.hashtable as htable
values = np.array([1, 2, 3, 5, 1, 3, 3, 2, 3, 5])
values_cnts = dict(zip(*htable.value_count_scalar64(values, dropna=True)))
print(values_cnts)

apply应用于DataFrame

有时，可能希望得到DataFrame中多个相关列的一张柱状图。例如：
>>>data = pd.DataFrame({'Qu1': [1, 3, 4, 3, 4],'Qu2': [2, 3, 1, 2, 3],'Qu3': [1, 5, 2, 4, 4]})
>>>data

Qu1  Qu2  Qu3
0    1    2    1
1    3    3    5
2    4    1    2
3    3    2    4
4    4    3    4

将 pandas.value_counts 传给该 DataFrame 的 apply 函数: 
In[25]: data.apply(pd.value_counts).fillna(0)
   Qu1  Qu2  Qu3
1  1.0  1.0  1.0
2  0.0  2.0  1.0
3  2.0  2.0  0.0
4  2.0  0.0  2.0
5  0.0  0.0  1.0

[ Histogramming and Discretization]

皮皮blog

索引对象obj.index

pandas的索引对象用来保存坐标轴标签和其它元数据（如坐标轴名或名称）。构建一个Series或DataFrame时任何数组或其它序列标签在内部转化为索引：

In [68]: obj = Series(range(3), index=['a', 'b', 'c'])
In [69]: index = obj.index
In [70]: index
Out[70]: Index([a, b, c], dtype=object)
In [71]: index[1:]
Out[71]: Index([b, c], dtype=object)

不可变性

索引对象是不可变的，因此不能由用户改变：

In [72]: index[1] = 'd'
Exception Traceback (most recent call last)...
Exception: <class 'pandas.core.index.Index'> object is immutable

索引对象的不可变性非常重要，这样它可以在数据结构中结构中安全的共享：

In [73]: index = pd.Index(np.arange(3))
In [74]: obj2 = Series([1.5, -2.5, 0], index=index)
In [75]: obj2.index is index
Out[75]: True

pandas中的主要索引对象

表格 是库中内建的索引类清单。通过一些开发努力，索引可以被子类化，来实现特定坐标轴索引功能。多数用户不必要知道许多索引对象的知识，但是它们仍然是pandas数据模型的重要部分。

固定大小集合功能

除了类似于阵列，索引也有类似固定大小集合一样的功能

In [76]: frame3
state Nevada Ohio
year
2000     NaN  1.5
2001     2.4  1.7
2002     2.9  3.6In [77]: 'Ohio' in frame3.columns
Out[77]: True
In [78]: 2003 in frame3.index
Out[78]: False

索引方法和属性

每个索引都有许多关于集合逻辑的方法和属性，且能够解决它所包含的数据的常见问题。

重建索引reindex

pandas对象的一个关键的方法是 reindex ，意味着使数据符合一个新的索引来构造一个新的对象。

reindex更多的不是修改pandas对象的索引，而只是修改索引的顺序，如果修改的索引不存在就会使用默认的None代替此行。且不会修改原数组，要修改需要使用赋值语句。

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

reindex 重排数据（行索引）

在Series上调用 reindex 重排数据，使得它符合新的索引，如果那个索引的值不存在就引入缺失数据值：

In [81]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
In [82]: obj2
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
In [83]: obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0

重建索引的内插或填充method

为了对时间序列这样的数据排序，当重建索引的时候可能想要对值进行内插或填充。 method 选项可以是你做到这一点，使用一个如ffill 的方法来向前填充值：

In [84]: obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
In [85]: obj3.reindex(range(6), method='ffill')
0   blue
1   blue
2 purple
3 purple
4 yellow
5 yellow

method 选项的清单

对于DataFrame， reindex 可以改变（行）索引，列或两者。当只传入一个序列时，结果中的行被重新索引了：

In [86]: frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])
In [87]: frameOhio Texas California
a    0     1          2
c    3     4          5
d    6     7          8

列重新索引关键字columns

使用 columns 关键字可以是列重新索引：

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

DataFrame重命名列columns方法2:

df.rename(columns={'age': 'x', 'fat_percent': 'y'})

行列同时重新索引2种方式

一次可以对两个重新索引，可是插值只在行侧（0坐标轴）进行：

In [92]: frame.reindex(index=['a', 'b', 'c', 'd'], method='ffill', columns=states)Texas Utah California
a      1  NaN          2
b      1  NaN          2
c      4  NaN          5
d      7  NaN          8

正如你将看到的，使用带标签索引的 ix 可以把重新索引做的更简单：

In [93]: frame.ix[['a', 'b', 'c', 'd'], states]Texas Utah California
a     1  NaN          2
b   NaN  NaN        NaN
c     4  NaN          5
d     7  NaN          8

SettingWithCopyWarning提示

SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame
df[len(df.columns) - 1][df[len(df.columns) - 1] > 0.0] = 1.0
这个warning主要是第二个索引导致的，就是说第二个索引是copy的。
奇怪的是，df的确已经修改了，而warnning提示好像是说修改被修改到df的一个copy上了。所以这里只是一个warnning，只是说和内存有关，可能赋值不上，也可能上了。
且print(df[ len(df.columns)  -  1][df[ len(df.columns)  -  1]  >  0.0].is_copy)输出None，怎么就输出None，而不是True或者False?
解决
修改df原本数据时建议使用loc，但是要注意行列的索引位置Try using .loc[row_indexer,col_indexer] = value instead

df.loc[df[len(df.columns) - 1] > 0.0, len(df.columns) - 1] = 1.0

不建议设置不提示：pd.options.mode.chained_assignment = None # default='warn'
参考前面why .ix is a bad idea部分
[为什么有这种warnning的官方解释：Returning a view versus a copy ¶]
[ Pandas SettingWithCopyWarning]
[ How to deal with SettingWithCopyWarning in Pandas?]

Why .ix is a bad idea

通过.ix选择的数据是一个copy的数据，修改这个选择不会修改原数据，而.loc是修改原数据。

The .ix object tries to do more than one thing, and for anyone who has read anything about clean code, this is a strong smell.

Given this dataframe:

df = pd.DataFrame({"a": [1,2,3,4], "b": [1,1,2,2]})

Two behaviors:

dfcopy = df.ix[:,["a"]]
dfcopy.a.ix[0] = 2

Behavior one: dfcopy is now a stand alone dataframe. Changing it will not change df

df.ix[0, "a"] = 3

Behavior two: This changes the original dataframe.

Use .loc instead

The pandas developers recognized that the .ix object was quite smelly[speculatively] and thus created two new objects which helps in the accession and assignment of data.

.loc is faster, because it does not try to create a copy of the data.

.loc is meant to modify your existing dataframe inplace, which is more memory efficient.

.loc is predictable, it has one behavior.

[Returning a view versus a copy]

皮皮blog

带有重复值的轴索引

带有重复索引值的Series

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

索引的is_unique属性

验证是否是唯一的
>>>obj.index.is_unique
False

带有重复值索引的数据选取

如果某个索引对应多个值，则 返回一个Series;而对应单个值的，则返回一个标量值。
>>>obj['a']
a    0
a    1
>>>obj['c']
4
对DataFrame的行进行索引时也是如此:
>>> df = DataFrame(np.random.randn(4, 3), index=['a','a','b','b'])
>>>df
>>> df.ix['b']

调整某条轴上各级别的顺序swaplevel

根据级别汇总统计

许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别，根据行或列上的级別来进行求和
In [29]: frame
state      Ohio     Colorado
color     Green Red    Green
key1 key2                   
a    1        0   1        2
     2        3   4        5
b    1        6   7        8
     2        9  10       11

In [30]: frame.sum(level='key2')
state  Ohio     Colorado
color Green Red    Green
key2                    
1         6   8       10
2        12  14       16
In [33]: frame.sum(level='color',axis=1)
color      Green  Red
key1 key2            
a    1         2    1
     2         8    4
b    1        14    7
     2        20   10
In [35]: frame.sum(level='color')
...
AssertionError: Level color not in index

[MultiIndex / Advanced Indexing]

from: http://blog.csdn.net/pipisorry/article/details/18012125

ref: [Indexing and Selecting Data¶]*