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

In [1]:
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 [5]:
# 创建Series带有可以对各个数据点进行标记的索引
obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
obj2
Out[5]:
d    4
b    7
a   -5
c    3
dtype: int64
In [6]:
obj2.index
Out[6]:
Index([u'd', u'b', u'a', u'c'], dtype='object')
In [7]:
obj2['a']
Out[7]:
-5

2. NumPy数组运算

In [8]:
obj2
Out[8]:
d    4
b    7
a   -5
c    3
dtype: int64
In [9]:
# 布尔表达式过滤
obj2[obj2 > 0]
Out[9]:
d    4
b    7
c    3
dtype: int64
In [10]:
# 标量乘法
obj2 * 2
Out[10]:
d     8
b    14
a   -10
c     6
dtype: int64
In [11]:
# 应用数学函数
np.exp(obj2)
Out[11]:
d      54.598150
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

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

In [12]:
'b' in obj2
Out[12]:
True
In [13]:
'e' in obj2
Out[13]:
False

3. 通过Python字典创建Series

In [14]:
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
# 传入Python字典,原字典的键成为Series的索引
obj3 = Series(sdata)
obj3
Out[14]:
Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64
In [15]:
sindex = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = Series(sdata, index=sindex)
# sdata中跟states索引项匹配的值会被找出来并放到相应的位置上
obj4
Out[15]:
California      NaN
Ohio          35000
Oregon        16000
Texas         71000
dtype: float64
In [16]:
obj4.isnull()
Out[16]:
California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

4. Series自动对齐

In [17]:
obj3 + obj4
Out[17]:
California       NaN
Ohio           70000
Oregon         32000
Texas         142000
Utah             NaN
dtype: float64

5. Series的name属性

In [18]:
obj4.name = 'population'
obj4.index.name = 'state'
obj4
Out[18]:
state
California      NaN
Ohio          35000
Oregon        16000
Texas         71000
Name: population, dtype: float64

6. 修改Series的索引

In [19]:
obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
obj
Out[19]:
Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

1.2 DataFrame

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

1. 构建DataFrame

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

In [20]:
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会自动加上索引,且全部被有序排列
Out[20]:
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
In [21]:
# 如果指定列序列,则DataFrame的列就会按照指定顺序进行排列
DataFrame(data, columns=['year', 'state', 'pop'])
Out[21]:
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
In [22]:
# 如果传入的列在数据中找不到,就会产生NA值
frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
         index=['one', 'two', 'three', 'four', 'five'])
frame2
Out[22]:
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

2. 对DataFrame的行和列的操作

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

In [23]:
frame2['state']
Out[23]:
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object
In [24]:
frame2.year
Out[24]:
one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int64

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

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

In [25]:
frame2.ix['three']
Out[25]:
year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object

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

In [26]:
frame2['debt'] = 16.5
In [27]:
frame2
Out[27]:
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

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

In [28]:
frame2['debt'] = [1, 2, 3, 4, 5]
frame2
Out[28]:
year state pop debt
one 2000 Ohio 1.5 1
two 2001 Ohio 1.7 2
three 2002 Ohio 3.6 3
four 2001 Nevada 2.4 4
five 2002 Nevada 2.9 5
In [29]:
val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
frame2['debt'] = val
frame2
Out[29]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 -1.2
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 -1.5
five 2002 Nevada 2.9 -1.7

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

In [30]:
frame2['eastern'] = frame2.state == 'Ohio'
In [31]:
frame2
Out[31]:
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 [32]:
del frame2['eastern']
In [33]:
frame2.columns
Out[33]:
Index([u'year', u'state', u'pop', u'debt'], dtype='object')
In [34]:
frame2
Out[34]:
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 -1.2
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 -1.5
five 2002 Nevada 2.9 -1.7

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

3. 传给DataFrame嵌套字典

如果数据形式是嵌套字典(字典的字典),将它传给DataFrame,它会被解释为:外层的键作为列,内层的键则作为行索引。

In [35]:
pop = {'Nevada': {2001: 2.4, 2002: 2.9},
      'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = DataFrame(pop)
frame3
Out[35]:
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6
In [36]:
# 对结果进行转置
frame3.T
Out[36]:
2000 2001 2002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6

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

  • 二维ndarray: 数据矩阵
  • 由数组、列表或元组组成的字典: 每个序列会变成DataFrame的一列。所有序列的长度必须相同
  • NumPy的结构化/记录数组: 类似于 有数组组成的字典
  • 由Series组成的字典
  • 由字典组成的字典
  • 字典或Series的列表
  • 由列表或元组组成的列表
  • 另一个DataFrame
  • NumPy的MaskedArray

4. DataFrame的属性

In [38]:
# 设置DataFrame的index和columns的name属性,并显示出来
frame3.index.name = 'year'
frame3.columns.name = 'state'
frame3
Out[38]:
state Nevada Ohio
year
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

DataFrame的values属性会以二维ndarray的形式返回DataFrame中的数据

In [39]:
frame3.values
Out[39]:
array([[ nan,  1.5],
       [ 2.4,  1.7],
       [ 2.9,  3.6]])

2. 索引对象

pandas的索引对象负责轴标签和其他元数据(比如轴名称等),构建Series或DataFrame时, 所用到的任何数组或其他序列的标签都会被转换成一个Index。Index对象是

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