pandas含有使数据分析工作变得更快更简单的高级数据结构和操作工具。pandas基于NumPy构建，让以NumPy为中心的应用变得更加简单。



In [13]:

    
import pandas as pd
from pandas import Series, DataFrame
import numpy as np

1. Pandas的数据结构

pandas的两个主要数据结构是：Series和DataFrame。

1.1 Series

Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据索引组成。

1. Series的构建



In [2]:

    
obj = Series([4, 7, -5, 3])
obj
# Series的字符串表现形式为：索引在左边，值在右边。
# 由于我们没有为数据指定索引，于是会自动创建一个0到N-1的整数索引









    Out[2]:





0    4
1    7
2   -5
3    3
dtype: int64



In [3]:

    
# 获取Series的values和index属性
obj.values









    Out[3]:





array([ 4,  7, -5,  3], dtype=int64)



In [4]:

    
obj.index









    Out[4]:





Int64Index([0, 1, 2, 3], dtype='int64')



In [6]:

    
# 创建Series带有可以对各个数据点进行标记的索引
obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
obj2









    Out[6]:





d    4
b    7
a   -5
c    3
dtype: int64



In [7]:

    
obj2.index









    Out[7]:





Index([u'd', u'b', u'a', u'c'], dtype='object')



In [8]:

    
obj2['a']









    Out[8]:





-5

2. NumPy数组运算



In [9]:

    
obj2









    Out[9]:





d    4
b    7
a   -5
c    3
dtype: int64



In [10]:

    
# 布尔表达式过滤
obj2[obj2 > 0]









    Out[10]:





d    4
b    7
c    3
dtype: int64



In [11]:

    
# 标量乘法
obj2 * 2









    Out[11]:





d     8
b    14
a   -10
c     6
dtype: int64



In [14]:

    
# 应用数学函数
np.exp(obj2)









    Out[14]:





d      54.598150
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

将Series看成是一个定长的有序字典，因为它是索引值到数据值的一个映射。



In [15]:

    
'b' in obj2









    Out[15]:





True



In [16]:

    
'e' in obj2









    Out[16]:





False

3. 通过Python字典创建Series



In [19]:

    
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
# 传入Python字典，原字典的键成为Series的索引
obj3 = Series(sdata)
obj3









    Out[19]:





Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64



In [20]:

    
sindex = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = Series(sdata, index=sindex)
# sdata中跟states索引项匹配的值会被找出来并放到相应的位置上
obj4









    Out[20]:





California      NaN
Ohio          35000
Oregon        16000
Texas         71000
dtype: float64



In [21]:

    
obj4.isnull()









    Out[21]:





California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

4. Series自动对齐



In [22]:

    
obj3 + obj4









    Out[22]:





California       NaN
Ohio           70000
Oregon         32000
Texas         142000
Utah             NaN
dtype: float64

5. Series的name属性



In [23]:

    
obj4.name = 'population'
obj4.index.name = 'state'
obj4









    Out[23]:





state
California      NaN
Ohio          35000
Oregon        16000
Texas         71000
Name: population, dtype: float64

6. 修改Series的索引



In [24]:

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









    Out[24]:





Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

1.2 DataFrame

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（功用同一个索引）。

1. 构建DataFrame

最常用是直接传入一个由等长列表或NumPy数组组成的字典



In [25]:

    
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
# DataFrame会自动加上索引，且全部被有序排列



In [26]:

    
# 如果指定列序列，则DataFrame的列就会按照指定顺序进行排列
DataFrame(data, columns=['year', 'state', 'pop'])



In [29]:

    
# 如果传入的列在数据中找不到，就会产生NA值
frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
         index=['one', 'two', 'three', 'four', 'five'])
frame2

2. 对DataFrame的行和列的操作

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



In [30]:

    
frame2['state']









    Out[30]:





one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object



In [31]:

    
frame2.year









    Out[31]:





one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int64

返回的Series拥有原DataFrame相同的索引，且其name属性已经被设置好了

用索引字段ix可以获得DataFrame的一行



In [32]:

    
frame2.ix['three']









    Out[32]:





year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object

列可以通过赋值的方式进行修改



In [33]:

    
frame2['debt'] = 16.5



In [34]:

    
frame2

将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series，就会精确匹配DataFrame的索引



In [36]:

    
frame2['debt'] = [1, 2, 3, 4, 5]
frame2



In [37]:

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

为不存在的列赋值会创建出一个新列



In [38]:

    
frame2['eastern'] = frame2.state == 'Ohio'



In [39]:

    
frame2









    Out[39]:






  
    
      
      year
      state
      pop
      debt
      eastern
    
  
  
    
      one
       2000
         Ohio
       1.5
       NaN
        True
    
    
      two
       2001
         Ohio
       1.7
      -1.2
        True
    
    
      three
       2002
         Ohio
       3.6
       NaN
        True
    
    
      four
       2001
       Nevada
       2.4
      -1.5
       False
    
    
      five
       2002
       Nevada
       2.9
      -1.7
       False

关键字del用于删除列



In [40]:

    
del frame2['eastern']



In [44]:

    
frame2.columns









    Out[44]:





Index([u'year', u'state', u'pop', u'debt'], dtype='object')



In [45]:

    
frame2

通过索引方式返回的列只是相应数据的视图而已，并不是副本。对返回的Series所做的任何修改都会反映到原DataFrame上。通过Series的copy方法即可显式地复制列。



In [ ]:

	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

	year	state	pop	debt
one	2000	Ohio	1.5	16.5
two	2001	Ohio	1.7	16.5
three	2002	Ohio	3.6	16.5
four	2001	Nevada	2.4	16.5
five	2002	Nevada	2.9	16.5

	year	state	pop	debt	eastern
one	2000	Ohio	1.5	NaN	True
two	2001	Ohio	1.7	-1.2	True
three	2002	Ohio	3.6	NaN	True
four	2001	Nevada	2.4	-1.5	False
five	2002	Nevada	2.9	-1.7	False