Pandas有两个主要的数据结构：Series和DataFrame．
Series是一种类似于一维数组的对象，它由一组数据以及一组与之相关的数据标签构成．来看下它的使用过程
In [1]: from pandas import Series,DataFrame
In [2]: import pandas as pd
In [3]: obj=Series([4,7,-5,3])
In [5]: obj
Out[5]:
0 4
1 7
2 -5
3 3
dtype: int64
通过Series生成的对象左边是索引，右边是具体的值．如果我们没有指定索引，那么会默认的生成一个．可以通过values和index来查看对应的值和索引．
In [6]: obj.values
Out[6]: array([ 4, 7, -5, 3])
In [7]: obj.index
Out[7]: RangeIndex(start=0, stop=4, step=1)
如果我们想指示索引，可以在生成的时候通过index来指示对应的索引
In [8]: obj2=Series([4,7,-5,3],index=[‘a‘,‘b‘,‘c‘,‘d‘])
In [9]: obj2
Out[9]:
a 4
b 7
c -5
d 3
dtype: int64
通过对应的索引就可以访问对应的值
In [10]: obj2[‘a‘]
Out[10]: 4
通过numpy数组运算后的结果也会保留索引和值之间的链接：
In [12]: np.exp(obj2)
Out[12]:
a 54.598150
b 1096.633158
c 0.006738
d 20.085537
dtype: float64
如果数据存在字典中，那么也可以通过这个字典来创建Series．创建之后索引就是字典中的key值．
In [13]: data={‘name‘:‘zhf‘,‘age‘:33,‘city‘:‘chengdu‘}
In [14]: obj3=Series(data)
In [15]: obj3
Out[15]:
age 33
city chengdu
name zhf
dtype: object
DataFrame:
DataFrame是一个表格形的数据结构．DataFrame既有行索引也有列索引，可以被看作是Series组成的字典．
In [25]: data={‘city‘:[‘chongqing‘,‘chengdu‘,‘beijing‘],‘weather‘:[‘rainy‘,‘suns
...: haw‘,‘snow‘],‘temperature‘:[9,5,-3]}
In [26]: frame=DataFrame(data)
In [27]: frame
Out[27]:
city temperature weather
0 chongqing 9 rainy
1 chengdu 5 sunshaw
2 beijing -3 snow
但是生成的数据的列索引和我们初始化data的时候不一样，如果我们想按照初始化data的索引顺序来生成的话就要在DataFrame中指定columns
In [28]: frame=DataFrame(data,columns=[‘city‘,‘weather‘,‘temperature‘])
In [29]: frame
Out[29]:
city weather temperature
0 chongqing rainy 9
1 chengdu sunshaw 5
2 beijing snow -3
同样的也可以指示行索引的值
In [30]: frame=DataFrame(data,columns=[‘city‘,‘weather‘,‘temperature‘],index=[‘f
...: irst‘,‘second‘,‘third‘])
In [31]: frame
Out[31]:
city weather temperature
first chongqing rainy 9
second chengdu sunshaw 5
third beijing snow -3
有了索引后就可以通过索引访问对应的行和列的数据．
通过列索引访问
In [33]: frame.city
Out[33]:
first chongqing
second chengdu
third beijing
Name: city, dtype: object
通过行索引访问
In [41]: frame.loc[‘first‘]
Out[41]:
city chongqing
weather rainy
temperature 9
Name: first, dtype: object
另外一种常见的形式就是嵌套字典(也就是字典的字典)
这种格式的生成外层字典的键作为列，内层键则作为行索引
In [42]: pop={‘cost‘:{2016:3000,2017:3400,2018:5000},‘need‘:{2017:4000,2018:6000
...: }}
In [43]: frame3=DataFrame(pop)
In [44]: frame3
Out[44]:
cost need
2016 3000 NaN
2017 3400 4000.0
2018 5000 6000.0
当然也可以转置
In [45]: frame3.T
Out[45]:
2016 2017 2018
cost 3000.0 3400.0 5000.0
need NaN 4000.0 6000.0
基本功能：
一 重新索引
首先来看下之前生成的数据，返回一个index对象．然后通过index[1]=’a’的形式来修改
In [50]: obj.index
Out[50]: RangeIndex(start=0, stop=4, step=1)
In [51]: index=obj.index
In [52]: index[1]=‘a‘
会提示如下的错误，Index does not support mutable operations．表示index对象是不可以修改的对象．因此无法通过这种方式进行修改
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-52-336c3a4c2807> in <module>()
----> 1 index[1]=‘a‘
/usr/local/lib/python2.7/dist-packages/pandas/core/indexes/base.pyc in __setitem__(self, key, value)
1722
1723 def __setitem__(self, key, value):
-> 1724 raise TypeError("Index does not support mutable operations")
1725
1726 def __getitem__(self, key):
TypeError: Index does not support mutable operations
要想修改序列，只能通过obj.reindex的方法．
In [60]: obj.reindex([‘a‘,‘b‘,‘c‘,‘d‘,‘e‘])
二丢弃指定轴上的项
可以通过drop的方法来丢弃某个行上的数据，参数即是行索引
In [64]: obj
Out[64]:
1 4
2 7
3 5
4 3
dtype: int64
In [65]: new=obj.drop(1)
In [66]: new
Out[66]:
2 7
3 5
4 3
dtype: int64
三索引，选取和过滤
在python的列表和元组中，我们可以通过切片来得到我们想要的信息，同样的在pandas中也可以通过切片来得到信息．
In [67]: obj[2:4]
Out[67]:
3 5
4 3
dtype: int64
对于之前的嵌套字典，也可以通过切片的方式进行访问．
In [81]: frame
Out[81]:
city weather temperature
first chongqing rainy 9
second chengdu sunshaw 5
third beijing snow -3
In [82]: frame[0:1]
Out[82]:
city weather temperature
first chongqing rainy 9
或者是通过ｉx来访问单个的行
In [83]: frame.ix[1]
Out[83]:
city chengdu
weather sunshaw
temperature 5
Name: second, dtype: object
三 算术运算和数据对齐
在对象进行相加的时候，如果存在不同的索引对，则结果的索引就是该索引的并集．如下面２个数据，只有一个索引’a’是能够对应得上的．因此相加后只有索引a才有结果其他都是空值
In [84]: s1=Series([1,2,3,4],index=[‘a‘,‘b‘,‘c‘,‘d‘])
In [85]: s2=Series([5,6,7,8],index=[‘x‘,‘a‘,‘y‘,‘z‘])
In [86]: s1+s2
Out[86]:
a 7.0
b NaN
c NaN
d NaN
x NaN
y NaN
z NaN
dtype: float64
四 在算术方法中填充值
前面介绍到如果相加后没有相同的索引值，那么对应的值就会被填充为NaN，如果我们期望填充某个固定的值比如０的话该如何操作呢，可以使用s1.add(s2,fill_value=0)的方式，这样的话就可以呈现出０而不是NaN
五 DataFrame和Series之间的运算
来看一个具体的例子
In [111]: frame=DataFrame(np.arange(12).reshape((4,3)),columns=list(‘bde‘),index
...: =[‘a1‘,‘a2‘,‘a3‘,‘a4‘])
In [119]: series=frame.ix[0]
In [120]: series
Out[120]:
b 0
d 1
e 2
Name: a1, dtype: int64
DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后进行相减
In [122]: frame
Out[122]:
b d e
a1 0 1 2
a2 3 4 5
a3 6 7 8
a4 9 10 11
In [123]: frame-series
Out[123]:
b d e
a1 0 0 0
a2 3 3 3
a3 6 6 6
a4 9 9 9
六 排序和排名
要对行或者列索引进行排序，可使用sort_index的方法，它将返回一个已排序的新对象
In [133]: frame
Out[133]:
e c d
a3 0 1 2
a2 3 4 5
a0 6 7 8
a1 9 10 11
对行索引进行排序
In [134]: frame.sort_index()
Out[134]:
e c d
a0 6 7 8
a1 9 10 11
a2 3 4 5
a3 0 1 2
对列索引进行排序
In [135]: frame.sort_index(axis=1)
Out[135]:
c d e
a3 1 2 0
a2 4 5 3
a0 7 8 6
a1 10 11 9
如果要对具体某一列的的数据进行排序的话可以采用传入参数by的方式．这里sort_index和sort_values都是一样的效果．
In [139]: frame.sort_values(by=‘d‘)
Out[139]:
e c d
a3 0 1 2
a2 3 4 5
a0 6 7 8
a1 9 10 11