求知 文章 文库 Lib 视频 iPerson 课程 认证 咨询 工具 讲座 Modeler   Code  
会员   
要资料
 
 

利用python进行数据分析
搭建python环境
统计 1880-2010 年间 全美婴儿姓名的趋势
Ipython & Ipython Notebook
NumPy Basics: Arrays and Vectorized Computation
Pandas(Python Data Analysis Library)
数据加载、储存与文件格式
绘图和可视化(Matplotlib)
时间序列
经济,金融数据应用
补充例子
国王与囚徒
利用python进行科学计算
分形与混沌之-Mandelbrot集合
分形与混沌之-迭代函数系统(IFS)
分形与混沌之-蔡氏电路模拟
对于μ子实验数据进行快速处理与分析
37%法则 - "非诚勿扰" 中的博弈
关于时间/日期的转换
深入研究
一切从游戏开始:完整的一个 python to hack 实例!
习题:扑克牌发牌
 
 

Pandas(Python Data Analysis Library)
270 次浏览
2次  
 捐助

Pandas(Python Data Analysis Library)

pandas简介:

pandas 是为了处理金融数据而开发的,它包含了高级的数据结构和精巧的工具,使得Python在处理数据时更加快速简单。

pandas 构建于NumPy之上,使得以NumPy为中心得应用很容易使用,它的特点有:

支持自动或明确的数据对齐的带有标签轴的数据结构。这可以防止由数据不对齐引起的常见错误,并可以处理不同来源的不同索引数据。

整合的时间序列功能。

以相同的数据结构来处理时间序列和非时间序列。

支持传递元数据(坐标轴标签)的算术运算和缩减。

灵活处理丢失数据。

在常用的基于数据的数据库(例如基于SQL)中的合并和其它关系操作。

参考网站 http://pandas.pydata.org/pandas-docs/stable/10min.html 10minutes To pandas

为了了解pandas,先要熟悉其中两个重要的数据结构:Series和DataFrame。它们提供了一个坚实的、易于使用的应用程序基础。

Series

Series是一个一维的类似数组的对象,包含一个数组的数据(任何NumPy的数据类型)和一个与数组关联的数据标签(索引)。

最简单的Series是由一个数组的数据构成:

In [4]: obj = Series([4, 7, -5, 3])
In [5]: obj
Out[5]:
0 4 # 左边的是索引(从0到N-1),右边是值
1 7
2 -5
3 3

可以分别的通过 values 和 index 属性来获取Series的数组表示和索引对象:

In [6]: obj.values
Out[6]: array([ 4, 7, -5, 3])
In [7]: obj.index
Out[7]: Int64Index([0, 1, 2, 3])

与正规的NumPy数组相比,你可以使用索引里的值来选择一个单一值或一个值集:

In [11]: obj2['a']
Out[11]: -5
In [12]: obj2['d'] = 6
In [13]: obj2[['c', 'a', 'd']]
Out[13]:
c 3
a -5
d 6

如果有一些数据在一个Python字典中,你可以通过传递字典来从这些数据创建一个Series:

In [20]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
In [21]: obj3 = Series(sdata)
In [22]: obj3
Out[22]:
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000113

只传递一个字典的时候,结果Series中的索引将是排序后的字典的建。

In [23]: states = ['California', 'Ohio', 'Oregon', 'Texas']
In [24]: obj4 = Series(sdata, index=states)
In [25]: obj4
Out[25]:
California NaN # 没有California的值所以显示 NaN(not a number)
Ohio 35000
Oregon 16000
Texas 71000

在pandas中用函数 isnull 和 notnull 来检测数据丢失:

In [26]: pd.isnull(obj4) In [27]: pd.notnull(obj4)
Out[26]: Out[27]:
California True California False
Ohio False Ohio True
Oregon False Oregon True
Texas False Texas True

在许多应用中Series的一个重要功能是在算术用算中它会自动对齐不同索引的数据:

In [29]: obj3 In [30]: obj4
Out[29]: Out[30]:
Ohio 35000 California NaN
Oregon 16000 Ohio 35000
Texas 71000 Oregon 16000
Utah 5000 Texas 71000

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

Series对象本身和它的索引都有一个 name 属性,它和pandas的其它一些关键功能整合在一起:

In [32]: obj4.name = 'population'
In [33]: obj4.index.name = 'state'
In [34]: obj4
Out[34]:
state
California NaN
Ohio 35000
Oregon 16000
Texas 71000
Name:population

Series的索引可以通过赋值就地更改:

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

DataFrame简介

DataFame是一个二维的数据结构,本质是Series的容器。可以包含一个索引以及与这些索引联合在一起的Series。

由于一个Series中的数据类型是相同的,而不同Series的数据结构可以不同。所以对于Data Frame 来说,每一列的数据结构是相同的,而不同的列之间的数据结构是不同的。

有很多方法来构建一个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)

如果设定了一个列的顺序,DataFrame的列将会精确的按照你所传递的顺序排列:

In [39]: DataFrame(data, columns=['year', 'state', 'pop'])
Out[39]:
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

和Series一样,如果你传递了一个行,但不包括在 data 中,在结果中它会表示为NA值:

In [40]: frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
....: index=['one', 'two', 'three', 'four', 'five'])
In [41]: frame2
Out[41]:
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

In [42]: frame2.columns
Out[42]: Index([year, state, pop, debt], dtype=object)

和Series一样,在DataFrame中的一列可以通过字典记法或属性来检索:

In [43]: frame2['state'] In [44]: frame2.year
Out[43]: Out[44]:
one Ohio one 2000
two Ohio two 2001
three Ohio three 2002
four Nevada four 2001
five Nevada five 2002
Name: state Name: year

列可以通过赋值来修改。例如,空的 ‘debt’ 列可以通过一个纯量或一个数组来赋值:

In [46]: frame2['debt'] = 16.5
In [47]: frame2
Out[47]:
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
In [48]: frame2['debt'] = np.arange(5.)
In [49]: frame2
Out[49]:
year state pop debt
one 2000 Ohio 1.5 0
two 2001 Ohio 1.7 1
three 2002 Ohio 3.6 2
four 2001 Nevada 2.4 3
five 2002 Nevada 2.9 4

另一种通用的数据形式是一个嵌套的字典的字典格式:

In [57]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},
....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

如果被传递到DataFrame,它的外部键会被解释为列索引,内部键会被解释为行索引:

In [58]: frame3 = DataFrame(pop)
In [59]: frame3
Out[59]:
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

如果被传递到DataFrame,它的外部键会被解释为列索引,内部键会被解释为行索引:

In [60]: frame3.T
Out[60]:
2000 2001 2002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6

内部字典的键被结合并排序来形成结果的索引。如果指定了一个特定的索引,就不是这样的了:

In [61]: DataFrame(pop, index=[2001, 2002, 2003])
Out[61]:
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN

Series的字典也以相同的方式来处理:

In [62]: pdata = {'Ohio': frame3['Ohio'][:-1],
....: 'Nevada': frame3['Nevada'][:2]}

In [63]: DataFrame(pdata)
Out[63]:
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7

像Series一样, values 属性返回一个包含在DataFrame中的数据的二维ndarray:

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

*如果DataFrame的列有不同的dtypes,返回值数组将会给所有的列选择一个合适的dtyps:

In [67]: frame2.values
Out[67]:
array([[2000, Ohio, 1.5, nan],
[2001, Ohio, 1.7, -1.2],
[2002, Ohio, 3.6, nan],
[2001, Nevada, 2.4, -1.5],
[2002, Nevada, 2.9, -1.7]], dtype=object)

索引对象

pandas的索引对象用来保存坐标轴标签和其它元数据(如坐标轴名或名称)。构建一个Series或DataFrame时任何数组或其它序列标签在内部转化为索引:

In [68]: obj = Series(range(3), index=['a', 'b', 'c'])
In [69]: index = obj.index
In [70]: index
Out[70]: Index([a, b, c], dtype=object)
In [71]: index[1:]
Out[71]: Index([b, c], dtype=object)

索引对象是不可变的,因此不能由用户改变:

In [72]: index[1] = 'd'
---------------------------------------------------------------------------
Exception Traceback (most recent call last)
<ipython-input-72-676fdeb26a68> in <module>()
----> 1 index[1] = 'd'
/Users/wesm/code/pandas/pandas/core/index.pyc in __setitem__(self, key, value)
302 def __setitem__(self, key, value):
303 """Disable the setting of values."""
--> 304 raise Exception(str(self.__class__) + ' object is immutable')
305
306 def __getitem__(self, key):
Exception: <class 'pandas.core.index.Index'> object is immutable

索引对象的不可变性非常重要,这样它可以在数据结构中结构中安全的共享:

In [73]: index = pd.Index(np.arange(3))
In [74]: obj2 = Series([1.5, -2.5, 0], index=index)
In [75]: obj2.index is index
Out[75]: True

除了类似于阵列,索引也有类似固定大小集合一样的功能:

In [76]: frame3
Out[76]:
state Nevada Ohio
year
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

In [77]: 'Ohio' in frame3.columns
Out[77]: True
In [78]: 2003 in frame3.index
Out[78]: False

重新索引

pandas对象的一个关键的方法是reindex, 意味着使数据符合一个新的索引来构造一个新的对象。

In [79]: obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
In [80]: obj
Out[80]:
d 4.5
b 7.2
a -5.3
c 3.6

在Series上调用 reindex 重排数据,使得它符合新的索引,如果那个索引的值不存在就引入缺失数据值:

In [81]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
In [82]: obj2
Out[82]:
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
In [83]: obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
Out[83]:
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0

为了对时间序列这样的数据排序,当重建索引的时候可能想要对值进行内插或填充。 method 选项可以是你做到这一点,使用一个如 ffill 的方法来向前填充值:

In [84]: obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
In [85]: obj3.reindex(range(6), method='ffill')
Out[85]:
0 blue
1 blue
2 purple
3 purple
4 yellow
5 yellow

* 对于DataFrame, reindex 可以改变(行)索引,列或两者。当只传入一个序列时,结果中的行被重新索引了:

In [86]: frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'],
....: columns=['Ohio', 'Texas', 'California'])
In [87]: frame
Out[87]:
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8

In [88]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])
In [89]: frame2
Out[89]:
Ohio Texas California
a 0 1 2
b NaN NaN NaN
c 3 4 5
d 6 7 8

使用 columns 关键字可以是列重新索引:

In [90]: states = ['Texas', 'Utah', 'California']
In [91]: frame.reindex(columns=states)
Out[91]:
Texas Utah California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8

一次可以对两个重新索引,可是插值只在行侧(0坐标轴)进行:

In [92]: frame.reindex(index=['a', 'b', 'c', 'd'], method='ffill',
....: columns=states)
Out[92]:
Texas Utah California
a 1 NaN 2
b 1 NaN 2
c 4 NaN 5
d 7 NaN 8

从一个坐标轴删除条目

从坐标轴删除一个多或多个条目是很容易的,如果有一个索引数组或列表且没有这些条目,但是这可能需要一点修改和集合逻辑。 drop 方法将会返回一个新的对象并从坐标轴中删除指定的一个或多个值:

In [94]: obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
In [95]: new_obj = obj.drop('c')
In [96]: new_obj
Out[96]:
a 0
b 1
d 3
e 4
In [97]: obj.drop(['d', 'c'])
Out[97]:
a 0
b 1
e 4

对于DataFrame,可以从任何坐标轴删除索引值:

In [98]: data = DataFrame(np.arange(16).reshape((4, 4)),
....: index=['Ohio', 'Colorado', 'Utah', 'New York'],
....: columns=['one', 'two', 'three', 'four'])

In [99]: data.drop(['Colorado', 'Ohio'])
Out[99]:
one two three four
Utah 8 9 10 11
New York 12 13 14 15

In [100]: data.drop('two', axis=1) In [101]: data.drop(['two', 'four'], axis=1)
Out[100]: Out[101]:
one three four one three
Ohio 0 2 3 Ohio 0 2
Colorado 4 6 7 Colorado 4 6
Utah 8 10 11 Utah 8 10
New York 12 14 15 New York 12 14

索引,挑选和过滤

Series索引( obj[…] )的工作原理类似与NumPy索引,除了可以使用Series的索引值,也可以仅使用整数来索引。下面是关于这一点的一些例子:

In [102]: obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
In [103]: obj['b'] In [104]: obj[1]
Out[103]: 1.0 Out[104]: 1.0
In [105]: obj[2:4] In [106]: obj[['b', 'a', 'd']]
Out[105]: Out[106]:
c 2 b 1
d 3 a 0
d 3

In [107]: obj[[1, 3]] In [108]: obj[obj < 2]
Out[107]: Out[108]:
b 1 a 0
d 3 b 1

使用标签来切片和正常的Python切片并不一样,它会把结束点也包括在内:

In [109]: obj['b':'c']
Out[109]:
b 1
c 2

您可以捐助,支持我们的公益事业。

1元 10元 50元





认证码: 验证码,看不清楚?请点击刷新验证码 必填



270 次浏览
2次
 捐助