pandas 入门

pandas 的数据结构介绍

pandas 有两个重要的数据结构：Series和DataFrame。

Series

Series是一个一维的类似的数组对象，包含一个数组的数据（任何NumPy的数据类型）和一个与数组关联的数据标签，被叫做 索引 。

obj = Series([4, 7, -5, 3])
obj
Ou:
0 4
1 7
2 -5
3 3

# 如果没有给数据指定索引，一个包含整数0到 N-1 （这里N是数据的长度）的默认索引被创建。
obj.values
Out: array([ 4, 7, -5, 3])
 obj.index
Out: Int64Index([0, 1, 2, 3])

obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
obj2
Out:
d 4
b 7
a -5
c 3

Series是一个定长的有序的字典，因为它把索引和值映射起来了。

'b' in obj2
Out: True
'e' in obj2
Out: False

可以通过传递一个 Python 字典来创建一个 Series：

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = Series(sdata)
obj3
Out:  # 结果是按照索引排序后的顺序
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000113

states = [‘California’, ‘Ohio’, ‘Oregon’, ‘Texas’]
obj4 = Series(sdata, index=states)
obj4 
Out: 
California NaN 
Ohio 35000 
Oregon 16000
Texas 71000

在这种情况下， sdata 中的3个值被放在了合适的位置，但因为没有发现对应于 ‘California’ 的值，就出现了 NaN （不是一个数），这在pandas中被用来标记数据缺失或 NA 值。我使用“missing”或“NA”来表示数度丢失。在pandas中用函数 isnull 和 notnull 来检测数据丢失：

pd.isnull(obj4)  # 或者使用实例方法obj4.isnull()
Out[26]:
California True
Ohio False
Oregon False
Texas False

Series的一个重要的功能是：它在运算中会自动对齐不同索引的数据。

obj3 + obj4
Out:
California NaN
Ohio 70000
Oregon 32000
Texas 142000
Utah NaN

Series对象本身和它的索引都有一个 name 属性，它和pandas的其它一些关键功能整合在一起：

obj4.name = 'population'
obj4.index.name = 'state'
obj4
Out:
state
California NaN
Ohio 35000
Oregon 16000
Texas 71000
Name: population

DataFrame

一个Datarame表示一个表格，类似电子表格的数据结构，包含一个经过排序的列表集，它们没一个都可以有不同的类型值（数字，字符串，布尔等等）。

有很多方法来构建一个DataFrame，但最常用的一个是用一个相等长度列表的字典或NumPy数组：

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data)
frame
Out:
  pop    state year
0 1.5     Ohio 2000
1 1.7     Ohio 2001
2 3.6     Ohio 2002
3 2.4   Nevada 2001
4 2.9   Nevada 2002

如果你设定了一个列的顺序，DataFrame的列将会精确的按照你所传递的顺序排列；和Series一样，如果你传递了一个行，但不包括在 data 中，在结果中它会表示为NA值：

frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
   ....: index=['one', 'two', 'three', 'four', 'five'])
frame2
Out:
       year state   pop debt
one    2000 Ohio    1.5  NaN
two    2001 Ohio    1.7  NaN
three  2002 Ohio    3.6  NaN
four   2001 Nevada  2.4  NaN
five   2002 Nevada  2.9  NaN

和Series一样，在DataFrame中的一列可以通过字典记法或属性来检索：

frame2['state']  # 或是使用属性 frame2.state
Out:
one   Ohio
two   Ohio 
three Ohio 
four  Nevada
five  Nevada
Name: state
# 注意，返回的Series包含和DataFrame相同的索引，并它们的 name 属性也被正确的设置了。

给一个不存在的列赋值，将会创建一个新的列。 像字典一样 del 关键字将会删除列。==索引DataFrame时返回的列是底层数据的一个视窗，而不是一个拷贝。因此，任何在Series上的就地修改都会影响DataFrame。列可以使用Series的 copy 函数来显式的拷贝。==

另一种通用的数据形式是一个嵌套的字典的字典格式，如果被传递到DataFrame，它的外部键会被解释为列索引，内部键会被解释为行索引：：

pop = {'Nevada': {2001: 2.4, 2002: 2.9},
   ....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
   
frame3 = DataFrame(pop)
frame3
Out:
     Nevada Ohio
2000    NaN  1.5
2001    2.4  1.7
2002    2.9  3.6

可以输入给 DataFrame 构造器的数据

DataFrame的 index 和 columns 有它们的 name，可以显示调用；跟 Series 一样，values 属性返回一个包含在 DataFrame 中的数据的二维 ndarray。

索引对象

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

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

索引对象是不可变的，因此不能由用户改变；索引对象的不可变性非常重要，这样它可以在数据结构中结构中安全的共享。

index[1] = 'd'  # 错误

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

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

索引方法和属性

基本功能

主要是操作 Series 和 DataFrame 中的数据的基本手段。

重新索引

pandas对象的一个关键的方法是 reindex ，创建一个适应新索引的新对象。

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

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

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

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

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

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

reindex 的（插值）method 选项

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

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

frame2 = frame.reindex(['a', 'b', 'c', 'd'])
In [89]: frame2
Out[89]:
  Ohio Texas California
a    0     1          2
b  NaN   NaN        NaN
c    3     4          5
d    6     7          8

# 使用columns关键字指定列重新索引
states = ['Texas', 'Utah', 'California']
In [91]: frame.reindex(columns=states)
Out[91]:
   Texas Utah California
a      1  NaN          2
c      4  NaN          5
d      7  NaN          8

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

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

使用带标签索引的 ix 可以把重新索引做的更简单：

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

reindex 函数的参数

丢弃指定轴上的项

从坐标轴删除一个多或多个条目是很容易的，如果你有一个索引数组或列表且没有这些条目，但是这可能需要一点修改和集合逻辑。 drop 方法将会返回一个新的对象并从坐标轴中删除指定的一个或多个值：

obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
new_obj
Out:
a   0
b   1
d   3
e   4

obj.drop(['d', 'c'])
Out:
a   0
b   1
e   4

对于DataFrame，可以从任何坐标轴删除索引值。如 data.drop('a',axis = 0)。

索引、选取和过滤

Series索引( obj[...] )的工作原理类似与NumPy索引，除了可以使用Series的索引值，也可以仅使用整数来索引。使用索引来切片和正常的Python切片并不一样，会包含结束点。

索引DataFrame来检索一个或多个列，可以使用一个单一值或一个序列：

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

可以通过切片或一个布尔数组来选择行：

data[:2]                       data[data['three'] > 5]
Out:                           Out:
         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   11
                               New York  12  13    14   15

在索引中使用一个布尔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
索引字段 ix 可以从DataFrame选择一个行和列的子集，使用像NumPy的记法再加上轴标签。

data.ix['Colorado',['two','three']]  # 或使用 data.ix['Colorado',[1,2]]
Out:
two     5
three   6
Name: Colorado

data.ix[:'Utah','two']
Out:
Ohio        0
Colorado    5
Utah        9
Name: two

data.ix[data.three > 5, :3]
Out:
         one two three
Colorado   4   5     6
Utah       8   9    10
New York   12 13    14

DataFrame 的索引选项

算术运算和数据对齐

pandas的最重要的特性之一是在具有不同索引的对象间进行算术运算的行为。当把对象加起来时，如果有任何的索引对不相同的话，在结果中将会把各自的索引联合起来。内部数据对其，在索引不重合的地方引入了NA值。

在算术方法中填充值

在不同索引对象间的算术运算，当一个轴标签在另一个对象中找不到时，你可能想要填充一个特定的值，如0：

df1 = DataFrame(np.arange(12).reshape((3,4)),columns=list('abcd'))
df2 = DataFrame(np.arange(20).reshape((4,5)),columns=list('abcde'))
df1 + df2

把它们加起来导致在不重合的位置出现NA值：

| a | b | c | d | e
--- | --- | --- | --- | --- | ---
0 | 0 | 2 | 4 | 6 | NaN
1 | 9 | 11 | 13 | 15 | NaN
2 | 18 | 20 | 22 | 24 | NaN
3 | NaN | NaN | NaN | NaN | NaN

在 df1 上使用 add 方法，我把 df2 传递给它并给 fill_value 赋了一个参数：

df1.add(df2,fill_value=0)

| a | b | c | d | e
--- | --- | --- | --- | --- | ---
0 | 0 | 2 | 4 | 6 | 4
1 | 9 | 11 | 13 | 15 | 9
2 | 18 | 20 | 22 | 24 | 14
3 | 15 | 16 | 17 | 18 | 19

灵活的算术方法

DataFrame 和 Series 之间的运算

DataFrame和Series间的算术运算Series的索引将匹配DataFrame的列，并在行上扩展。如果一个索引值在DataFrame的列和Series的索引里都找不着，对象将会从它们的联合重建索引。如果想在行上而不是列上进行扩展，你要使用一个算术方法。例如：

frame = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                  index=['Utah', 'Ohio', 'Texas', 'Oregon'])

frame

| b | d | e
--- | --- | --- | ---
Utah | 0 | 1 | 2
Ohio | 3 | 4 | 5
Texas | 6 | 7 | 8
Oregon | 9 | 10 | 11

series = frame['d']
frame.sub(series, axis=0)

| b | d | e
--- | --- | --- | ---
Utah | -1 | 0 | 1
Ohio | -1 | 0 | 1
Texas | -1 | 0 | 1
Oregon | -1 | 0 | 1

函数应用和映射

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

frame = DataFrame(np.random.randn(4, 3), columns=list('bde'),
                  index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame
Out:
        b           d           e
Utah    -0.204708   0.478943    -0.519439
Ohio    -0.555730   1.965781    1.393406
Texas   0.092908    0.281746    0.769023
Oregon  1.246435    1.007189    -1.296221

np.abs(frame)  # frame 的元素的绝对值
Out:
        b           d           e
Utah    0.204708    0.478943    0.519439
Ohio    0.555730    1.965781    1.393406
Texas   0.092908    0.281746    0.769023
Oregon  1.246435    1.007189    1.296221

将函数应用到由各列或行所形成的一维数组上。DataFrame 的 apply 方法既可以实现此功能：

f = lambda x: x.max() - x.min()
frame.apply(f)
Out:
    b    1.802165
    d    1.684034
    e    2.689627
    dtype: float64

frame.apply(f, axis=1)
Out:
Utah      0.998382
Ohio      2.521511
Texas     0.676115
Oregon    2.542656
dtype: float64

许多最为常见的数组统计方法都被实现成 DataFrame 方法（如 sum 和 mean），因此无须使用 apply 方法。

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

def f(x):
    return Series([x.min(), x.max()], index=['min', 'max'])
frame.apply(f)
Out:
    b           d           e
min -0.555730   0.281746    -1.296221
max 1.246435    1.965781    1.393406

此外，元素级的 Python 函数也是可以用的。要得到 frame 中各个浮点值的格式化字符串，使用 applymap (之所以叫 applymap ，是因为 Series 有一个用于应用元素级函数的 map 方法)即可：

format = lambda x: '%.2f' % x
frame.applymap(format)
Out:
    b       d       e
Utah    -0.20   0.48    -0.52
Ohio    -0.56   1.97    1.39
Texas   0.09    0.28    0.77
Oregon  1.25    1.01    -1.30

frame['e'].map(format)
Out:
Utah      -0.52
Ohio       1.39
Texas      0.77
Oregon    -1.30
Name: e, dtype: object

排序和排名

根据条件对数据集排序（sorting）也是一种重要的内置运算。

对 Series 用sort_index方法排序：

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

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

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

数据默认是生序排序的，但也可以将序排序：

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

按值对 Series 进行排序，可以使用 order 方法：

obj = Series([4, 7, -3, 2])
obj.order()
Out:
2   -3
3    2
0    4
1    7
dtype: int64

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

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

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

默认情况下，rank 是通过“为各组分配一个平均排名”的方式破坏平级关系：

obj = Series([7, -5, 7, 4, 2, 0, 4])
obj.rank()
Out:
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

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

obj.rank(method='first')
Out:
0    6
1    1
2    7
3    4
4    3
5    2
6    5
dtype: float64

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

带有重复值的轴索引

索引的 is_unique 属性可以查看索引值是否唯一。

如果某个索引对应多个值，则返回一个 Series；而对应单个值得，则返回一个标量值。对 DataFrame 的行进行索引时也是如此。

汇总和计算描述统计

pandas 对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值（如 sum 或 mean）或从 DataFrame 的行货列中提取一个 Series。跟对应的 Numpy 数组方法相比，它们都是基于没有缺失数据的假设而构建的。

描述和汇总统计

相关系数和协方差

Series 的 corr 和 cov 方法用于计算两个 Series 中重叠的、非NA的、按索引对齐的值得相关系数和协方差。

DataFrame 的 corr 和 cov 方法将以 DataFrame 的形式返回完整的相关系数或协方差矩阵。

DataFrame 的 corrwith 方法可以计算其列或行跟另一个 Series 或 DataFrame 之间的相关系数。

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

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

将pandas.value_counts 传给 DataFrame 的 apply 函数：

data = DataFrame({'Qu1': [1, 3, 4, 3, 4],
                  'Qu2': [2, 3, 1, 2, 3],
                  'Qu3': [1, 5, 2, 4, 4]})
data
Out:
    Qu1 Qu2 Qu3
0   1   2   1
1   3   3   5
2   4   1   2
3   3   2   4
4   4   3   4

result = data.apply(pd.value_counts).fillna(0)
result
Out:
    Qu1 Qu2 Qu3
1   1   1   1
2   0   2   1
3   2   2   0
4   2   0   2
5   0   0   1

处理缺失数据

NA 处理方法

滤除缺失数据

对于 DataFrame 对象，dropna 默认丢弃任何含有缺失值的行：

data = DataFrame([[1., 6.5, 3.], [1., NA, NA],
                  [NA, NA, NA], [NA, 6.5, 3.]])
cleaned = data.dropna()
data
Out:
    0   1   2
0   1   6.5 3
1   1   NaN NaN
2   NaN NaN NaN
3   NaN 6.5 3

cleaned
Out:
    0   1   2
0   1   6.5 3

传入 how = 'all' 将只丢弃全为 NA 的那些行：

data.dropna(how='all')
Out:
    0   1   2
0   1   6.5 3
1   1   NaN NaN
3   NaN 6.5 3

填充缺失数据

fillna 方法是主要的填充函数。

通过一个字典调用 fillna，可以实现对不同的列填充不同的值：

df = DataFrame(np.random.randn(7, 3))
df.ix[:4, 1] = NA; df.ix[:2, 2] = NA
df
Out:
    0   1   2
0   0.274992    NaN NaN
1   0.886429    NaN NaN
2   1.669025    NaN NaN
3   0.476985    NaN -1.021228
4   -0.577087   NaN 0.302614
5   0.523772    0.000940    1.343810
6   -0.713544   -0.831154   -2.370232

df.fillna({1: 0.5, 3: -1})
Out:
    0   1   2
0   0.274992    0.500000    NaN
1   0.886429    0.500000    NaN
2   1.669025    0.500000    NaN
3   0.476985    0.500000    -1.021228
4   -0.577087   0.500000    0.302614
5   0.523772    0.000940    1.343810
6   -0.713544   -0.831154   -2.370232

fillna 函数的参数

层次化索引

层次化索引时 pandas 的一项重要功能，它是你能在一个轴上拥有多个索引级别。

data = Series(np.random.randn(10),
              index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],
                     [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
data
Out:
a  1   -0.204708
   2    0.478943
   3   -0.519439
b  1   -0.555730
   2    1.965781
   3    1.393406
c  1    0.092908
   2    0.281746
d  2    0.769023
   3    1.246435
dtype: float64

data.index
Out:
MultiIndex(levels=[[u'a', u'b', u'c', u'd'], [1, 2, 3]],
           labels=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 1, 2]])

层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要角色。如 data 可以通过其 unstack 方法被重新安排到一个 DataFrame 中：

data.unstack()
Out:
    1           2           3
a   -0.204708   0.478943    -0.519439
b   -0.555730   1.965781    1.393406
c   0.092908    0.281746    NaN
d   NaN         0.769023    1.246435
# unstack 的逆运算是 stack。

对于一个 DataFrame，每条轴都可以有分层索引：

frame = DataFrame(np.arange(12).reshape((4, 3)),
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
                  columns=[['Ohio', 'Ohio', 'Colorado'],
                           ['Green', 'Red', 'Green']])
frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']
frame

Out:
        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

重排分级顺序

swaplevel 接受两个级别编号或名称，并返回一个互换了级别的新对象：

frame.swaplevel('key1', 'key2')
Out:
    state   Ohio        Colorado
        color   Green   Red Green
key2    key1            
1   a   0   1   2
2   a   3   4   5
1   b   6   7   8
2   b   9   10  11

sortlevel 根据单个级别中的值对数据进行排序。

frame.swaplevel(0, 1).sortlevel(0)
Out:
    state   Ohio    Colorado
        color   Green   Red Green
key2    key1            
1   a   0   1   2
        b   6   7   8
2   a   3   4   5
        b   9   10  11

根据级别汇总统计

许多对 DataFrame 和 Series 的描述和汇总统计都有一个 level 选项，它用于指定某条周上求和的级别。

frame.sum(level='color', axis=1)
Out:
    color   Green   Red
key1    key2        
a   1   2   1
        2   8   4
b   1   14  7
        2   20  10
# 这其实利用了 pandas 的 groupby 功能。

使用 DataFrame 的列

DataFrame 的 set_index 函数可以将 DataFrame 的一个或多个列当做行索引来用，而 reset_index 函数则是将行索引变成 DataFrame 的列。

frame = DataFrame({'a': range(7), 'b': range(7, 0, -1),
                   'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'],
                   'd': [0, 1, 2, 0, 1, 2, 3]})
frame
Out:
    a   b   c   d
0   0   7   one 0
1   1   6   one 1
2   2   5   one 2
3   3   4   two 0
4   4   3   two 1
5   5   2   two 2
6   6   1   two 3

frame2 = frame.set_index(['c', 'd'])  # 可以加入参数 drop=False 保留数据中的c、d列。
frame2
Out:
        a   b
c   d       
one 0   0   7
        1   1   6
        2   2   5
two 0   3   4
        1   4   3
        2   5   2
        3   6   1

frame2.reset_index()
Out:
    c   d   a   b
0   one 0   0   7
1   one 1   1   6
2   one 2   2   5
3   two 0   3   4
4   two 1   4   3
5   two 2   5   2
6   two 3   6   1

其他有关 pandas 的话题

整数索引

操作由整数索引的 pandas 对象跟内置的 Python 数据结构（如列表和元组）在索引语义上有些不同。例如：

ser = Series(np.arange(3.))
ser[-1]

==会产生错误。==
对于一个非整数索引，就没有问题。为了保持良好的一致性，尽量保持操作时面向标签的，同样包括用 ix 进行切片。如果需要可靠的、不考虑索引类型的、基于位置的索引，可以使用 Series 的 iloc 或 iat 方法和 DataFrame 的 irow 和 icol 方法：

ser.iloc[-1]
Out:
2.0

frame = DataFrame(np.arange(6).reshape((3, 2)), index=[2, 0, 1])
frame.iloc[0]
Out:
0    0
1    1
Name: 2, dtype: int32

面板数据

pandas 有一个 Panel 数据结构，可以将其看作一个三维版的 DataFrame。pandas 的大部分开发工作都集中在表格型数据上，所以这些事数据更常见。