python数据分析之Pandas：基本功能介绍

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