Pandas简介和使用

Contents
  1. Pandas数据读取性能
  2. 基本数据结构
    1. Series
    2. DataFrame
  3. Pandas使用
    1. 读取csv文件
      1. 普通办法读取
      2. 用Pandas读取
  4. 一个pandas实例

Pandas是基于NumPy的一个非常好用的库,正如名字一样,人见人爱。之所以如此,就在于不论是读取、处理数据,用它都非常简单。此前有一篇文章《别老扯什么Hadoop了,你的数据根本不够大》指出:只有在超过5TB数据量的规模下,Hadoop才是一个合理的技术选择。相对小一些的数据,我这两天发现使用Python + Pandas处理起来更加敏捷。

安装Pandas非常简单,只需要一行命令(当然你需要先安装pip):

1
pip install pandas

Pandas数据读取性能

Pandas提供了IO工具可以将大文件分块读取,测试了一下性能,完整加载9800万条数据也只需要263秒左右,还是相当不错了。

根据测试,对于不同数据量的数据读取时间如下:

1百万条 1千万条 1亿条
Data 1s 17s 263s

基本数据结构

Pandas有两种自己独有的基本数据结构。应该注意的是,它固然有着两种数据结构,因为它依然是python的一个库,所以,python中有的数据类型在这里依然适用,也同样还可以使用类自己定义数据类型。只不过,Pandas里面又定义了两种数据类型:Series和DataFrame,它们让数据操作更简单了。

以下操作都是基于:

1
2
from pandas import Series, DataFrame
import pandas as pd

Series

Series就如同列表一样,是一系列数据,每个数据对应一个索引值。比如这样一个列表:[9, 3, 8],如果跟索引值写到一起,就是:

data 9 3 8
index 0 1 2

这种样式我们已经熟悉了,不过,在有些时候,需要把它竖过来表示:

index data
0 9
1 3
2 8

上面两种,只是表现形式上的差别而已,而Series就是竖起来的list:

1
2
3
4
5
6
7
>>> s = Series([100, "PYTHON", "Soochow", "Qiwsir"])
>>> s
0 100
1 PYTHON
2 Soochow
3 Qiwsir
dtype: object

另外一点也很像列表,就是里面的元素的类型,由你任意决定(其实是由需要来决定)。

这里,我们实质上创建了一个Series对象,这个对象当然就有其属性和方法了。比如,下面的两个属性依次可以显示Series对象的数据值和索引:

1
2
3
4
5
>>> s.values
array([100, 'PYTHON', 'Soochow', 'Qiwsir'], dtype=object)
>>>
>>> s.index
RangeIndex(start=0, stop=4, step=1)

列表的索引只能是从0开始的整数,Series数据类型在默认情况下,其索引也是如此。不过,区别于列表的是,Series可以自定义索引:

1
2
3
4
5
6
7
8
9
10
>>> s2 = Series([100, "PYTHON", "Soochow", "Qiwsir"], \
... index=["mark", "title", "university", "name"])
>>> s2
mark 100
title PYTHON
university Soochow
name Qiwsir
dtype: object
>>> s2.index
Index([u'mark', u'title', u'university', u'name'], dtype='object')

每个元素都有了索引,就可以根据索引操作元素了。类似于list中的操作,根据索引查看其值和修改其值:

1
2
3
4
5
6
7
8
9
>>> s2["name"]
'Qiwsir'
>>> s2["name"] = "AOI"
>>> s2
mark 100
title PYTHON
university Soochow
name AOI
dtype: object

某种程度上,还有些类似dict操作数据;如果对此不太理解,可以看下面的例子。

前面定义Series对象的时候,用的是列表,即Series()方法的参数中,第一个列表就是其数据值,如果需要定义index,放在后面,依然是一个列表。除了这种方法之外,还可以用下面的方法定义Series对象:

1
2
3
4
5
6
7
>>> sd = {"python":8000, "c++":8100, "c":4000}
>>> s4 = Series(sd)
>>> s4
c 4000
c++ 8100
python 8000
dtype: int64

现在是否理解为什么前面那个类似dict了?因为本来就是可以这样定义的。

这时候,索引依然可以自定义。Pandas的优势在这里体现出来,如果自定义了索引,自定的索引会自动寻找原来的索引,如果一样的,就取原来索引对应的值,这个可以简称为“自动对齐”。

1
2
3
4
5
6
7
>>> s6 = Series(sd, index=["java", "python", "c++", "c"])
>>> s6
java NaN
python 8000.0
c++ 8100.0
c 4000.0
dtype: float64

在sd中,只有'python':8000, 'c++':8100, 'c':4000,没有"java",但是在索引参数中有,于是其它能够“自动对齐”的照搬原值,没有的那个"java",依然在新Series对象的索引中存在,并且自动为其赋值NaN。在Pandas中,如果没有值,都对齐赋给NaN

1
2
3
4
5
6
7
8
9
10
11
12
>>> pd.isnull(s6)
java True
python False
c++ False
c False
dtype: bool
>>> pd.notnull(s6)
java False
python True
c++ True
c True
dtype: bool

此外,Series对象也有同样的方法:

1
2
3
4
5
6
>>> s6.isnull()
java True
python False
c++ False
c False
dtype: bool

对于Series数据,也可以做类似下面的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> s3 = Series([3, 9, 4, 7], index=['a', 'b', 'c', 'd'])
>>> s3
a 3
b 9
c 4
d 7
dtype: int64
>>> s3[s3 > 5]
b 9
d 7
dtype: int64
>>> s3 * 5
a 15
b 45
c 20
d 35
dtype: int64

DataFrame

DataFrame是一种二维的数据结构,非常接近于电子表格或者类似mysql数据库的形式。它的竖行称之为columns,横行跟前面的Series一样,称之为index,也就是说可以通过columns和index来确定一个主句的位置。

1
2
3
4
5
6
7
8
9
10
11
>>> import pandas as pd
>>> from pandas import Series, DataFrame
>>> data = {"name":["yahoo","google","facebook"], \
... "marks":[200,400,800], "price":[9, 3, 7]}
>>> f1 = DataFrame(data)
>>> f1
marks name price
0 200 yahoo 9
1 400 google 3
2 800 facebook 7

这是定义一个DataFrame对象的常用方法——使用dict定义。字典的“键”(”name”,”marks”,”price”)就是DataFrame的columns的值(名称),字典中每个“键”的“值”是一个列表,它们就是那一竖列中的具体填充数据。上面的定义中没有确定索引,所以,按照惯例(Series中已经形成的惯例)就是从0开始的整数。从上面的结果中很明显表示出来,这就是一个二维的数据结构(类似excel或者mysql中的查看效果)。

上面的数据显示中,columns的顺序没有规定,就如同字典中键的顺序一样,但是在DataFrame中,columns跟字典键相比,有一个明显不同,就是其顺序可以被规定,像下面这样做:

1
2
3
4
5
6
>>> f2 = DataFrame(data, columns=['name','price','marks'])
>>> f2
name price marks
0 yahoo 9 200
1 google 3 400
2 facebook 7 800

跟Series类似的,DataFrame数据的索引也能够自定义。

1
2
3
4
5
6
>>> f3 = DataFrame(data, columns=['name', 'price', 'marks', 'debt'], index=['a','b','c'])
>>> f3
name price marks debt
a yahoo 9 200 NaN
b google 3 400 NaN
c facebook 7 800 NaN

还要注意观察上面的显示结果。因为在定义f3的时候,columns的参数中,比以往多了一项(‘debt’),但是这项在data这个字典中并没有,所以debt这一竖列的值都是空的,在Pandas中,空就用NaN来代表了。

定义DataFrame的方法,除了上面的之外,还可以使用“字典套字典”的方式。

1
2
3
4
5
6
>>> newdata = {"lang":{"firstline":"python","secondline":"java"}, "price":{"firstline":8000}}
>>> f4 = DataFrame(newdata)
>>> f4
lang price
firstline python 8000.0
secondline java NaN

在字典中就规定好数列名称(第一层键)和每横行索引(第二层字典键)以及对应的数据(第二层字典值),也就是在字典中规定好了每个数据格子中的数据,没有规定的都是空。

1
2
3
4
5
>>> DataFrame(newdata, index=["firstline","secondline","thirdline"])
lang price
firstline python 8000.0
secondline java NaN
thirdline NaN NaN

如果额外确定了索引,就如同上面显示一样,除非在字典中有相应的索引内容,否则都是NaN。

前面定义了DataFrame数据(可以通过两种方法),它也是一种对象类型,比如变量f3引用了一个对象,它的类型是DataFrame。承接以前的思维方法:对象有属性和方法。

1
2
>>> f3.columns
Index([u'name', u'price', u'marks', u'debt'], dtype='object')

DataFrame对象的columns属性,能够显示现有的columns名称。并且,还能用下面类似字典的方式,得到某竖列的全部内容(当然包含索引):

1
2
3
4
5
>>> f3['name']
a yahoo
b google
c facebook
Name: name, dtype: object

这是什么?这其实就是一个Series,或者说,可以将DataFrame理解为是由一个一个的Series组成的。

对于没有数值的那一列,下面的操作是统一给那一列赋值:

1
2
3
4
5
6
>>> f3['debt'] = 89.2
>>> f3
name price marks debt
a yahoo 9 200 89.2
b google 3 400 89.2
c facebook 7 800 89.2

除了能够统一赋值之外,还能够“点对点”添加数值,结合前面的Series,既然DataFrame对象的每竖列都是一个Series对象,那么可以先定义一个Series对象,然后把它放到DataFrame对象中。如下:

1
2
>>> sdebt = Series([2.2, 3.3], index=["a","c"]) #注意索引
>>> f3['debt'] = sdebt

将Series对象(sdebt变量所引用) 赋给f3[‘debt’]列,Pandas的一个重要特性——自动对齐——在这里起做用了,在Series中,只有两个索引(”a”,”c”),它们将和DataFrame中的索引自动对齐。于是有:

1
2
3
4
5
>>> f3
name price marks debt
a yahoo 9 200 2.2
b google 3 400 NaN
c facebook 7 800 3.3

自动对齐之后,没有被复制的依然保持NaN。

Pandas使用

由于篇幅限制,不能讲pandas所有内容完全详尽描述,只是做一个简单的介绍,在实践中使用如果遇到问题,建议参考相关文档或者google来解决(不要用baidu)。

读取csv文件

普通办法读取

最简单、最直接的就是open()打开文件:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> with open("./marks.csv") as f:
... for line in f:
... print line
...
name,physics,python,math,english
Google,100,100,25,12
Facebook,45,54,44,88
Twitter,54,76,13,91
Yahoo,54,452,26,100

此方法可以,但略显麻烦。python中还有一个csv的标准库:

1
2
3
>>> import csv
>>> dir(csv)
['Dialect', 'DictReader', 'DictWriter', 'Error', 'QUOTE_ALL', 'QUOTE_MINIMAL', 'QUOTE_NONE', 'QUOTE_NONNUMERIC', 'Sniffer', 'StringIO', '_Dialect', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__version__', 'excel', 'excel_tab', 'field_size_limit', 'get_dialect', 'list_dialects', 're', 'reader', 'reduce', 'register_dialect', 'unregister_dialect', 'writer']

从上面结果可以看出,csv模块提供的属性和方法。仅仅就读取本例子中的文件:

1
2
3
4
5
6
7
8
9
10
>>> import csv
>>> csv_reader = csv.reader(open("./marks.csv"))
>>> for row in csv_reader:
... print row
...
['name', 'physics', 'python', 'math', 'english']
['Google', '100', '100', '25', '12']
['Facebook', '45', '54', '44', '88']
['Twitter', '54', '76', '13', '91']
['Yahoo', '54', '452', '26', '100']

算是稍有改善。

用Pandas读取

我们来看一下pandas的效果:

1
2
3
4
5
6
7
8
>>> import pandas as pd
>>> marks = pd.read_csv("./marks.csv")
>>> marks
name physics python math english
0 Google 100 100 25 12
1 Facebook 45 54 44 88
2 Twitter 54 76 13 91
3 Yahoo 54 452 26 100

以上结果就是一个DataFrame数据对象。

还有另外一种方法:

1
2
3
4
5
6
>>> pd.read_table("./marks.csv", sep=",")
name physics python math english
0 Google 100 100 25 12
1 Facebook 45 54 44 88
2 Twitter 54 76 13 91
3 Yahoo 54 452 26 100

如果你有足够的好奇心来研究这个名叫DataFrame的对象,可以这样:

1
2
>>> dir(marks)
['T', '_AXIS_ALIASES', '_AXIS_NAMES', '_AXIS_NUMBERS', '__add__', '__and__', '__array__', '__array_wrap__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__div__', '__doc__', '__eq__', '__floordiv__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__neg__', '__new__', '__nonzero__', '__or__', '__pow__', '__radd__', '__rdiv__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__setitem__', '__setstate__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__weakref__', '__xor__', '_agg_by_level', '_align_frame', '_align_series', '_apply_broadcast', '_apply_raw', '_apply_standard', '_auto_consolidate', '_bar_plot', '_boolean_set', '_box_item_values', '_clear_item_cache', '_combine_const', '_combine_frame', '_combine_match_columns', '_combine_match_index', '_combine_series', '_combine_series_infer', '_compare_frame', '_consolidate_inplace', '_constructor', '_count_level', '_cov_helper', '_data', '_default_stat_axis', '_expand_axes', '_from_axes', '_get_agg_axis', '_get_axis', '_get_axis_name', '_get_axis_number', '_get_item_cache', '_get_numeric_data', '_getitem_array', '_getitem_multilevel', '_helper_csvexcel', '_het_axis', '_indexed_same', '_init_dict', '_init_mgr', '_init_ndarray', '_is_mixed_type', '_item_cache', '_ix', '_join_compat', '_reduce', '_reindex_axis', '_reindex_columns', '_reindex_index', '_reindex_with_indexers', '_rename_columns_inplace', '_rename_index_inplace', '_sanitize_column', '_series', '_set_axis', '_set_item', '_set_item_multiple', '_shift_indexer', '_slice', '_unpickle_frame_compat', '_unpickle_matrix_compat', '_verbose_info', '_wrap_array', 'abs', 'add', 'add_prefix', 'add_suffix', 'align', 'append', 'apply', 'applymap', 'as_matrix', 'asfreq', 'astype', 'axes', 'boxplot', 'clip', 'clip_lower', 'clip_upper', 'columns', 'combine', 'combineAdd', 'combineMult', 'combine_first', 'consolidate', 'convert_objects', 'copy', 'corr', 'corrwith', 'count', 'cov', 'cummax', 'cummin', 'cumprod', 'cumsum', 'delevel', 'describe', 'diff', 'div', 'dot', 'drop', 'drop_duplicates', 'dropna', 'dtypes', 'duplicated', 'fillna', 'filter', 'first_valid_index', 'from_csv', 'from_dict', 'from_items', 'from_records', 'get', 'get_dtype_counts', 'get_value', 'groupby', 'head', 'hist', 'icol', 'idxmax', 'idxmin', 'iget_value', 'index', 'info', 'insert', 'irow', 'iteritems', 'iterkv', 'iterrows', 'ix', 'join', 'last_valid_index', 'load', 'lookup', 'mad', 'max', 'mean', 'median', 'merge', 'min', 'mul', 'ndim', 'pivot', 'pivot_table', 'plot', 'pop', 'prod', 'product', 'quantile', 'radd', 'rank', 'rdiv', 'reindex', 'reindex_axis', 'reindex_like', 'rename', 'rename_axis', 'reorder_levels', 'reset_index', 'rmul', 'rsub', 'save', 'select', 'set_index', 'set_value', 'shape', 'shift', 'skew', 'sort', 'sort_index', 'sortlevel', 'stack', 'std', 'sub', 'sum', 'swaplevel', 'tail', 'take', 'to_csv', 'to_dict', 'to_excel', 'to_html', 'to_panel', 'to_records', 'to_sparse', 'to_string', 'to_wide', 'transpose', 'truncate', 'unstack', 'values', 'var', 'xs']

一个一个浏览一下,通过名字可以直到那个方法或者属性的大概,然后就可以根据你的喜好和需要,试一试:

1
2
3
4
5
6
>>> marks.index
Int64Index([0, 1, 2, 3], dtype=int64)
>>> marks.columns
Index([name, physics, python, math, english], dtype=object)
>>> marks['name'][1]
'Facebook'

下面几个操作,也是常用到的,并且秉承了python的一贯方法:

1
2
3
4
5
6
7
8
9
10
11
12
>>> marks[:1]
name physics python math english
0 Google 100 100 25 12
>>> marks[1:2]
name physics python math english
1 Facebook 45 54 44 88
>>> marks["physics"]
0 100
1 45
2 54
3 54
Name: physics

可以说,当你已经掌握了通过dir()和help()查看对象的方法和属性时,就已经掌握了pandas的用法,其实何止pandas,其它对象都是如此。

一个pandas实例

上周一个朋友提出了一个简单的需求:对于百万条数量级的csv文件做一个简单的数据分析,在此非常感谢他让我有机会接触到了pandas,话不多说,上代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import pandas as pd
import datetime, csv
def get_data(rows, key, count):
data_max, data_min = rows[key].max(), rows[key].min()
data_avg = (rows[key].sum() / float(count)) if count != 0 else 0
return data_max, data_min, data_avg
if __name__ == "__main__":
starttime = datetime.datetime.now()
data = pd.read_csv("new_colla.csv")
with open('degree_year.csv','ab+') as ft:
writer = csv.writer(ft)
for i in range(n):
for j in range(m):
rows = data[(data.degree1==i) & (data.degree2==j)]
# Get valuable data
age, count = (i, j), rows.colla_time.count()
if count == 0:
continue
colla_time_max, colla_time_min, colla_time_avg = get_data(rows, "colla_time", count)
coarticle_num_max, coarticle_num_min, coarticle_num_avg = get_data(rows, "coarticle_num", count)
# Write file
write_obj = [age, colla_time_max, colla_time_min, colla_time_avg, \
coarticle_num_max, coarticle_num_min, coarticle_num_avg, count]
writer.writerow(write_obj)
endtime = datetime.datetime.now()
print (endtime - starttime).seconds