Padans入门（cover：利用python进行数据分析）

一、Series

1.Series一种类似于一维数组的对象，由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。

（1）用一组数据产生最简单的Series：

from pandas import Series,DataFrame
import pandas as pd

obj = Series([4,7,-5,3])
print(obj)

2.Series的字符串表现形式为：索引在左边，值在右边。没有为数据指定索引，就会自动创建一个0到N-1（N为数据的长度）的整数型索引。

（1）通过values和index属性获取其数组表示形式和被索引对象：

print(obj.values)
print(obj.index)

（2）创建的Series带有一个可以对各个数据点进行标记的索引：

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

（3）与普通numpy数组相比，索引选取Series中的单一或一组值：

print(obj2['a'])
obj2['d'] = 6
print(obj2[['c','a','d']])

（4）Numpy数组运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引和值之间的链接：

import numpy as np
print(obj2)
print(obj2[obj2 > 0])
print(obj2 * 2)
print(np.exp(obj2))

（5）可将Series看做一个定长的有序字典，它是索引值到数据的一个映射。可以用在许多原本需要字典参数的函数中：

print('b' in obj2)
print('e' in obj2)

（6）若数据被存放在一个python字典中，可以直接通过这个字典来创建Series：

sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
ojb3 = Series(sdata)
print(ojb3)

（7）若只传入一个字典，则结果Series中的索引就是原字典的键（有序排列）：

states = ['California','Ohio','Oregon','Texas']
ojb4 = Series(sdata,index=states)
print(ojb4)  #结果中的NaN即非数字，用于表示缺失或NA值

（8）pandas中isnull和notnull函数用于检测缺失数据：

print(pd.isnull(ojb4))
print(pd.notnull(ojb4))

（9）Series中检测缺失数据：

print(ojb4.isnull())

（10）Series最重要的一个功能：它在算术运算中会自动对齐不同索引的数据：

print(ojb3)
print(ojb4)
print(ojb3 + ojb4)

（11）Series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能关系密切：

ojb4.name = 'population'
ojb4.index.name = 'state'
print(ojb4)

(12)Series的索引可以通过赋值的方式就地修改：

obj.index = ['Bob','Steve','Jeff','Ryan']
print(obj)

二、DataFrame

DataFrame是一个表格型的数据结构。它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，可以看做由Series组成的字典（共用一个索引）。dataframe中的数据是以一个或多个二维存放的（而不是列表、字典或别的一维数据结构）。

1.构建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)

2.结果DataFrame会自动加上索引（和Series一样），且全部列会被有序排列：

print(frame)

3.若指定了列序列，则DataFrame的列就会按照指定顺序进行排列：

print(DataFrame(data,columns=['year','state','pop']))

4.和Series相同，若传入的列在数据中找不到，就会产生NA值：

frame2 = DataFrame(data,columns=['year','state','pop','debt'],
                   index=['one','two','three','four','five'])
print(frame2)
print(frame2.columns)

5.通过类似字典标记的方式或属性的方式，可将DataFrame的列获取为一个Series：

print(frame2['state'])
print(frame2.year)

6.注意：返回的Series有原DataFrame相同的索引，且其name属性也已经被相应地设置好了。行也可以通过位置或名称地方式进行获取，例如用索引字段ix（python3中已弃用）：

print(frame2.loc['three'])  #书中ix函数python3中已没有

7.列可以通过赋值地方式进行修改。例如，可以给空的“debt”列赋上一个标量值或一组值：

frame2['debt'] = 16.5
print(frame2)
frame2['debt'] = np.arange(5.)
print(frame2)

8.将列表或数组赋值给某列时，其长度必须跟DataFrame的长度相匹配。若赋值的是一个Series，就会精确匹配DataFarme的索引，所有的空位都将被填上缺失值：

val = Series([-1.2,-1.5,-1.7],index=['two','four','five'])
frame2['debt'] = val
print(frame2)

9.为不存在的列赋值会创建出一个新列。关键字del用于删除列：

frame2['eastern'] = frame2.state == 'Ohio'
print(frame2)
del frame2['eastern']
print(frame2.columns)

10.另一种常见的数据形式是嵌套字典（字典的字典）：

pop = {'Nevada':{2001:2.4,2002:2.9},
'Ohio':{2000:1.5,2001:1.7,2002:3.6}}

11.若将它传给DataFrame，它就会被解释为：外层字典的键作为列，内层键则作为行索引：

frame3 = DataFrame(pop)
print(frame3)

12.也可对该结果进行转置：

print(frame3.T)

13.内层字典的键会被合并、排序以形成最终的索引。若显示指定了索引，则不会这样：

print(DataFrame(pop,index=[2001,2002,2003]))

14.Series组成的字典也类似这样的用法：

pdata = {'Ohio':frame3['Ohio'][:-1],
         'Nevada':frame3['Nevada'][:2]}
print(DataFrame(pdata))

15.如果设置了DataFrame的index和columns的name属性，则这些信息也会被显示出来：

frame3.index.name = 'year';frame3.columns.name = 'state'
print(frame3)

16.和Series一样，values属性也会以二维ndarray的形式返回DataFrame中的数据：

print(frame3.values)

17.若DataFarme各列的数据类型不同，则值数组的数据类型就会选用能兼容所有列的数据类型：

print(frame2.values)

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

三、索引对象

pandas的索引对象负责管理轴标签和其他元数据（轴名称等）。

1.构建Series或DataFrame时，所用到的任何数组或其他序列的标签都会被转换成一个Index：

obj = Series(range(3),index=['a','b','c'])
index = obj.index
print(index)
print(index[1:])

2.Index对象是不可修改的，所以用户不能对其进行修改，这样能使Index对象在多个数据结构之间安全共享：

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

3.Index可以被继承从而实现特别的轴索引功能。

pandas中主要的Index对象

4.Index的功能类似一个固定大小的集合：

print(frame3)
print('Ohio' in frame3.columns)
print(2003 in frame3.index)

Index的方法和属性

四、重新索引

1.reindex作用是创建一个适应新索引的新对象。例：

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

2.调用该Series的reindex将会根据新索引进行重排。若某个索引值当前不存在，就引入缺失值：

obj2 = obj.reindex(['a','b','c','d','e'])
print(obj2)
print(obj.reindex(['a','b','c','d','e'],fill_value=0))

3.对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method选项即可，例如使用ffill可以实现前向值填充：

obj3 = Series(['blue','purple','yellow'],index=[0,2,4])
print(obj3.reindex(range(6),method='ffill'))

reindex的（插值）method选项

4.对于DataFrame，reindex可以修改（行）索引、列，或两个都修改。若仅传入一个序列，则会重新索引行：

frame = DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],
                  columns=['Ohio','Texas','California'])
print(frame)
frame2 = frame.reindex(['a','b','c','d'])
print(frame2)

5.使用columns关键字可重新索引列：

states = ['Texas','Utah','California']
print(frame.reindex(columns=states))

6.也可同时对行和列进行重新索引，而插值则只能按行应用（即轴0）：

print(frame.reindex(index=['a','b','c','d'],method='ffill',
                    columns=states))   #运行报错尚未解决

reindex函数的参数

五、丢弃指定轴上的项

1.drop方法返回的是一个在指定轴上删除了指定值的新对象：

obj = Series(np.arange(5.),index=['a','b','c','d','e'])
new_obj = obj.drop('c')
print(new_obj)
print(obj.drop(['d','c']))

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

data = DataFrame(np.arange(16).reshape((4,4)),
                 index=['Ohio','Colorado','Utah','New York'],
                 columns=['one','teo','three','four'])
data.drop(['Colorado','Ohio'])
data.drop('two',axis=1)   #运行报错尚未解决

六、索引、选取和过滤

1.Series的索引值不只是整数，例：

obj = Series(np.arange(4.),index=['a','b','c','d'])
print(obj['b'])
print(obj[1])
print(obj[2:4])
print(obj[['b','a','d']])
print(obj[[1,3]])
print(obj[obj < 2])

2.利用标签的切片运算末端为封闭区间：

print(obj['b':'c'])

3.设置方式：

obj['b':'c'] = 5
print(obj)

4.DataFrame索引即获取一个或多个列：

data = DataFrame(np.arange(16).reshape((4,4)),
                 index=['Ohio','Colorado','Utah','New York'],
                 columns=['one','two','three','four'])
print(data)
print(data['two'])   #报错
print(data['three','one'])  #报错

5.通过布尔型DataFrame进行索引：

print(data < 5)
data[data < 5] = 0
print(data)

DataFrame的索引选项（ix已无）

七、算术运算和数据对齐

1.pandas可对不同索引的对象进行算术运算。

（1）在相加对象时，若存在不同的索引，则结果的索引就是该索引对的并集。自动的数据对齐操作在不重叠的索引处引入了NA值。缺失值会在算术运算过程中传播：

s1 = Series([7.3,-2.5,3.4,1.5],index=['a','c','d','e'])
s2 = Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])
print(s1)
print(s2)
print(s1 + s2)

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

df1 = DataFrame(np.arange(9.).reshape((3,3)),columns=list('bcd'),
                index=['Ohio','Texas','Colorado'])
df2 = DataFrame(np.arange(12.).reshape((4,3)),columns=list('bde'),
                index=['Utah','Ohio','Texas','Oregon'])
print(df1)
print(df2)
print(df1 + df2)

2.在算术方法中填充值

（1）在对不同索引对象进行算术运算时，当一个对象中某轴标签在另一个对象中找不到时填充一个特殊值（比如0）：

df1 = DataFrame(np.arange(9.).reshape((3,3)),columns=list('bcd'),
                index=['Ohio','Texas','Colorado'])
df2 = DataFrame(np.arange(12.).reshape((4,3)),columns=list('bde'),
                index=['Utah','Ohio','Texas','Oregon'])
print(df1)
print(df2)
print(df1 + df2)  #没有重叠的位置产生NA值

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

print(df1.add(df2,fill_value=0))

（3）在对Series或DataFrame重新索引时，可以指定一个填充值：

print(df1.reindex(columns=df2.columns,fill_value=0))

灵活的算术方法

3.DataFrame和Series之间的运算

（1）计算一个二维数组与其某行之间的差，即广播：

arr = np.arange(12.).reshape((3,4))
print(arr)
print(arr[0])

（2）DataFrame和Series之间的运算：

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

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

print(frame - series)

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

series2 = Series(range(3),index=['b','e','f'])
print(frame + series2)

（5）若想匹配行在列上广播，必须使用算术运算方法，例如：

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

八、函数应用和映射

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

frame = DataFrame(np.random.randn(4,3),columns=list('bde'),
                  index=['Utah','Ohio','Texas','Oregon'])
print(frame)
print(np.abs(frame))

2.DataFrame的apply方法可将函数应用到由各列或行所形成的一堆数组上：

f = lambda x:x.max() - x.min()
print(frame.apply(f))
print(frame.apply(f,axis=1))

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

def f(x):
    return  Series([x.min(),x.max()],index=['min','max'])
print(frame.apply(f))

4.为得到frame中各个浮点值的格式化字符串，使用applymap（元素级的python函数）：

format = lambda x:'%.2f' %x
print(frame.applymap(format))

5.Series中有一个用于应用元素级函数的map方法：

print(frame['e'].map(format))

九、排序和排名

1.根据条件对数据集排序是一种重要的内置运算。

(1)对行或列索引进行排序（按字典排序），可使用sort_index方法，将返回一个已排序的新对象：

obj = Series(range(4),index=['d','a','b','c'])
print(obj.sort_index())

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

frame = DataFrame(np.arange(8).reshape((2,4)),index=['three','one'],
                  columns=['d','a','b','c'])
print(frame.sort_index())
print(frame.sort_index(axis=1))
print(frame.sort_index(axis=1,ascending=False))   #默认为升序，可降序

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

obj = Series([4,7,-3,2])
print(obj.order())   #报错order

(4)DataFarme根据一个或多个列中的值进行排序。将一个或多个列的名字传递给by选项：

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

(5)根据多个列进行排序，传入名称的列表：

print(frame.sort_index(by='a','b'))    #报错

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

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

obj = Series([7,-5,7,4,2,0,4])
print(obj.rank())

(2)可根据值在原数据中出现的顺序给出排名（类似于稳定排序）：

print(obj.rank(method='first'))
print(obj.rank(ascending=False,method='max'))   #降序

(3)DataFrame可以在行或列上计算排名：

frame = DataFrame({'b':[4.3,7,-3,2],'a':[0,1,0,1],
                   'c':[-2,5,8,-2.5]})
print(frame)
print(frame.rank(axis=1))

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

十、带有重复值的轴索引

1.简单的带有重复索引值的Series：

obj = Series(range(5),index=['a','a','b','b','c'])
print(obj)

2.索引的is_unique属性检查值是否是唯一的：

print(obj.index.is_unique)

3.对于带有重复值的索引，数据选取会不同。若某个索引对应多个值，则返回一个Series；而对应单个值，则返回一个标量值。

print(obj['a'])
print(obj['c'])

4.对DataFrame的行进行索引也一样：

df = DataFrame(np.random.randn(4,3),index=['a','a','b','b'])
print(df)
print(df.loc['b'])

十一、汇总和计算描述统计

1.pandas数学统计方法大部分属于约简和汇总统计和numpy比，都是基于没有缺失数据的假设而构建的。例如一个简单的DataFrame：

df = DataFrame([[1.4,np.nan],[7.1,-4.5],
                [np.nan,np.nan],[0.75,-1.3]],
               index=['a','b','c','d'],
               columns=['one','two'])
print(df)

2.调用DataFarm的sum方法将会返回一个含有列小计的Series：

print(df.sum())

3.传入axis=1将会按行进行求和：

print(df.sum(axis=1))

4.NA值会自动被排除，除非整个切片（指行或列）都是NA。通过skipna选项可以禁用该功能：

print(df.mean(axis=1,skipna=False))

约简方法的选项

5.idmin和idmax返回的是间接统计，cumsum是累计型，：

print(df.idxmax())
print(df.cumsum())

6.describe既不是约简型也不是累计型，用于一次性产生多个汇总统计，而非数值型数据，它会产生另外一种汇总统计：

print(df.describe())
obj = Series(['a','a','b','c'] * 4)
print(obj.describe())

描述和汇总统计

十二、相关系数与协方差

通过参数对计算出来

1.Yahoo!Finance的股票价格和成交量（无数据源所以打不开，代码仅供参考）：

import pandas.io.data as web
all_data = {}
for ticker in ['AAPL','IBM','MSFT','GOOG']:
    all_data[ticker] = web.get_data_yahoo(ticker,'1/1/2000','1/1/2010')
price = DataFrame({tic: data['Adj Close']
                      for tic, data in all_data.iteritems()})
volume = DataFrame({tic: data['Volume']
                      for tic, data in all_data.iteritems()})

2.计算价格百分数变化：

return = price.pct_change()
print(return.tail())

3.Series的 corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值相关系数。类似的，cov计算协方差：

print(returns.MSFT.corr(return.IBM))
print(returns.MSFT.cov(return.IBM))

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

print(return.corr())
print(return.cov())

5.DataFrame的corrwith方法，可以计算其列或行跟另一个Sreies或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算）：

print(returns.corrwith(return.IBM))

6.传入一个DataFrame会计算按列名配对的相关系数。传入axis=1可按行进行计算。在计算相关系数之前所有的数据项都会按标签对齐：

print(returns.corrwith(volume))   #计算百分比变化与成交量的相关系数

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

1.从一维Series的值中抽取信息，函数unique，可以得到Series中的唯一值数组：

obj = Series(['c','a','d','a','a','b','b','c','c'])
uniques = obj.unique()
print(uniques)

2.返回的唯一值是未排序的，如果需要，可以对结果再次进行排序（uniques.sort()）。value_counts用于计算一个Series中各值出现的频率：

print(obj.value_counts())

3.为了方便查看，结果 Series是按值频率降序排序的。value_counts还是一个顶级pandas方法，可用于任何数组或序列：

print(pd.value_counts(obj.values,sort=False))

4.isin用于判断矢量化集合的成员资格，可用于选取Series中或DataFrame列中数据的子集：

mask =obj.isin(['b','c'])
print(mask)
print(obj[mask])

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

5.为了得到DataFrame中多个相关列的一张柱状图。例如：

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

6.将pandas.value_counts传给该DataFrame的apply函数，就会出现：

result = data.apply(pd.value_counts).fillna(0)
print(result)

十四、处理缺失数据

1.pandas使用浮点值NaN表示浮点和非浮点数组中的缺失数据。仅是一个便于被检测出来的标记：

string_data = Series(['aardvark','artichoke',np.nan,'avocado'])
print(string_data)
print(string_data.isnull())

2.python内置的None值也会被当做NA处理：

string_data[0] = None
print(string_data.isnull())

NA处理方法

十五、滤除缺失数据

1.对于一个Series，dropna返回一个仅含非空数据和索引值的Series:

from numpy import nan as NA
data = Series([1,NA,3.5,NA,7])
print(data.dropna())

2.也可以用布尔型索引：

print(data[data.notnull()])

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

data = DataFrame([[1.,6.5,3.],[1.,NA,NA],
                  [NA,NA,NA],[NA,6.5,3]])
cleaned = data.dropna()
print(data)
print(cleaned)

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

print(data.dropna(how='all'))

5.丢弃列，传入axis=1即可：

data[4] = NA
print(data)
print(data.dropna(axis=1,how='all'))

6.另一个滤除DataFreme行问题涉及时间序列数据。若只想留下一部分观测数据，可用thresh参数：

df = DataFrame(np.random.randn(7,3))
df.loc[:4,1] = NA; df.loc[:2,2] = NA
print(df)
print(df.dropna(thresh=3))

十六、填充缺失数据

1.fillna方法，将缺失值替换为被调用的常数值：

print(df.fillna(0))

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

print(df.fillna({1:0.5,3:-1}))

3.fillna默认返回新对象，也可以对现有对象进行就地修改：

# 总是返回被填充对象的引用
_ = df.fillna(0,inplace=True)
print(df)

4.对reindex有效的那些插值方法也课用于fillna：

df = DataFrame(np.random.randn(6,3))
df.loc[2:,1] = NA; df.loc[4:,2] = NA
print(df)
print(df.fillna(method='ffill'))
print(df.fillna(method='ffill',limit=2))

5.可以用fillna传入Series的平均值或中位数等：

data = Series([1.,NA,3.5,NA,7])
print(data.fillna(data.mean()))

fillna函数的参数

十七、层次化索引

层次化索引可以在一个轴上拥有多个（两个以上）索引级别。即能以低维度形式处理高维度数据。

1.例如：创建一个Series用一个由列表或数组组成的列表作为索引：

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]])
print(data)

2.带有MultiIndex索引的Series的格式化输出形式。索引之间的“间隔”表示“直接使用上面的标签”：

print(data.index)

3.一个层次化索引对象，选取数据子集操作：

print(data['b'])
print(data['b':'c'])
print(data.loc[['b','d']])

4.有时可以在“内层”中进行选取：

print(data[:,2])

5.层次化索引在数据重塑和基于分组的操作（如透视表生成）中很重要。例如，这段数据可通过unstack方法被重新安排到一个DataFrame中：

print(data.unstack())
print(data.unstack().stack())   #unstack的逆运算是stack

6.对于一个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']])
print(frame)

7.各层都可以有名字（可以是字符串，也可以是别的python对象）。若指定了名称，他们就会显示在控制台输出中（不能将索引名称和轴标签混为一谈！）：

frame.index.names = ['key1','key2']
frame.columns.names = ['state','color']
print(frame)

8.有了分部的列索引，可以选取列分组：

print(frame['Ohio'])

9.可以单独创建MultiIndex然后复用。上面的DataFrame中的（分级的）列可以这样创建：

print(MultiIndex.from_arrays([['Ohio','Ohio','Colorado'],['Green','Red','Green']],
                             names=['state','color']))     #报错

十八、重排分级排序

重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。

1.swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：

print(frame.swaplevel('key1','key2'))

2.sortlevel根据单个级别中的值对数据进行排序（稳定的）。交换级别，常常也会用到sortlevel，最终结果就有序了：

print(frame.swaplevel(1))
print(frame.swaplevel((0,1).sortlevel(0)))    #报错，无sortlevel

十九、根据级别汇总统计

1.根据行或列上的级别来进行求和，pandas的groupby：

print(frame.sum(level='key2'))
print(frame.sum(level='color',axis=1))

二十、使用DataFrame的列

1.set_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]})
print(frame)
frame2 = frame.set_index(['c','d'])
print(frame2)

2.默认，那些列会从DataFrame中移除，但也可以将其保留下来：

print(frame.set_index(['c','d'],drop=False))

3.reset_index和set_index相反，层次化索引的级别会被转移到列里面：

print(frame2.reset_index())

二一、其他关于pandas的话题

1.整数索引

可靠的、不考虑引类型的、基于位置的索引，可使用Series的iget_value方法和DataFrame的irow和icol方法：

ser3 = Series(range(3),index=[-5,1,3])
print(ser3.iget_values(2))
frame = DataFrame(np.arange(6).reshape(3,2),index=[2,0,1])
print(frame.irow(0))      #报错，无iget_values

2.面板数据