《AI时代就业指南：那些年我们一起追的数据科学》沙龙活动 6月17号，相约深大，免费报名。活动内容：《哈佛商业评论》把数据科学成为21世纪最性感的职位！35所高校新发布了《数据科学与大数据技术》专业你知道吗？数据科学家到底有多牛？如何迎接人工智能时代？/event/0
> 【量化小讲堂- Python、pandas技巧系列】如何快速上手使用Python进行金融数据分析
根据之前的反馈，让我觉的很有必要写一篇如何快速上手使用Pyhton进行系列分析的帖子。本文主要以此为主题，介绍下我学习量化投资、Python的个人经验。
第一步：好奇心
不要为了学习而去学习一门编程语言，或者任何工具。一定要心里首先有一个问题，抱着解决问题的心态，去了解并学习这个工具是如何解决问题的。驱动你去学习量化投资的，应该是你的好奇心。你认为你有一个炒股独家的窍门，你认为你发现了某个规律，你非常好奇的想用历史数据去验证你的想法。
比如我在大二的时候接触量化投资，就是因为我的好奇心。当时我看到一些入门的技术分析书上推荐KDJ这个技术指标，说KDJ低位金叉之后股票会涨，是个很好的买入信号，并且书上会配一些图，证明这个指标的有效性。我当时就很好奇，书上说的是不是真的？这几个配图是刻意挑选的还是有代表性的？是不是可以写个程序找出历史上所有的kdj金叉，看看之后涨的概率有多大?
这就是引领我入门的最初的好奇心。当时我不会编程，一开始用excel来试着验证，发现KDJ从大概率上来讲是不行的。好奇心继续升级：我调整一下KDJ默认的参数，效果会不会好一点？再配合一下其他的指标，效果会不会好一点？再加上点财务数据，效果会不会好一点……
慢慢的想测试的想法越来越多，excel渐渐的不够用，开始学习编程。我学习编程的目的性很强，就是解决我眼前的问题。对于解决我问题没有帮助的，我就先不学。一开始用的是SAS，自己找书看，论坛上发帖子问。后来觉得SAS太重，不灵活，慢慢的迁移到Python。
我是金融专业的，但是学校并不教量化投资，一切都是自己学。可想而知，若没有好奇心一直引导我去探索，这么长的一段时间我怎么可能坚持下来呢？
第二步：为什么Python
我推荐刚入门的量化投资研究者使用Python。主要理由如下：
Python配合各类第三方的package（例如下面要降到的pandas），是非常适合用来处理金融数据的
相比于c，c#等语言，Python容易太多了。让你可以更快，更方便的对自己的想法进行测试。life is short, use Python。
Matlab是另外一个金融分析领域的统治级语言，以上讲的两点适用性、简单性matlab都是具备的，在业界的使用范围应该是比Python要高的。
而Python相比于matlab的一大优势，那就是全能。matlab基本只能用于金融数据分析。但是Python除了拥有不亚于matlab的矩阵计算、科学计算能力之外，其他几乎任何事情都可以做。比如数据的清理、整理，比如从网页上抓取数据，比如进行文本信息的挖掘，比如做一个网站……现在学习一门语言，将来在任何地方都能用到。
第三步：如何入门Python
如果你有其他语言的编写经验（比如上过一个学期的编程课），有一定的编程基础。以下三步可以让你入门Python：
1. 随便找一本Pyhton入门书。这些教程网上有很多很多，论坛里面也有很多，随便搜索一下就是。我稍微整理了下，放在附件中，回复可见。
2. 挑一本Python入门书，不要花超过半天的时间，快速翻阅这本书。这个步骤不求记住什么东西，只要大概的知道这本书讲了什么，什么知识在这本书的哪一章写了就行，以便将来查阅。
3. 结合自己的好奇心，给自己寻找一个问题，简单的复杂的都可以，找一点数据(地址)，直接开始实战。遇到问题，第一步是去翻书，第二步是去google(别去百度)，第三步是论坛发帖求助。若你没有什么思路或者问题，可以加群，我可以给你提供思路。
如果你没有任何编程的基础，那么想要入门Python，也是以上三个步骤。但是第2步，就不是仅仅花半天的时间浏览书了，而是要细细的看书。对着书上的例子，实际的操作下，大概花一个星期的时间的业余时间也就够了吧。
第四步：如何入门pandas
使用Python做金融数据分析，一定要用pandas。pandas是Python的一个第三方库，简直是金融数据分析的神器，第一次遇到它的时候让我泪流满面。了解pandas最好的途径就是他的官方文档：http://pandas.pydata.org/pandas-docs/stable/10min.html，当然也可以看我之前写的系列文章。
作者：邢不行
本文来自: 人大经济论坛
相关文章：
转载请注明： &
or分享 (0)物品推荐-Pandas-Python数据分析(22) – 运维生存时间
你可能喜欢
有回复时邮件通知我
12345678910
12345678910
关于本站 本站以分享运维技术为主，欢迎大家参与技术分享，同时也欢迎大家吐槽，本站提供以下交流圈：QQ群①：*****（满）QQ群②：6690706 QQ群③： QQ群④：（新） 微信公众号：ttlsacom 商务合作QQ：
记住我的登录信息
点击“立即注册”转到用户注册页面。
输入用户名或电子邮箱地址，您会收到一封新密码链接的电子邮件。
用户名或电子邮件地址Python大数据处理模块Pandas_经验技巧_动态网站制作指南
Python大数据处理模块Pandas
来源：人气：94
Pandas使用一个二维的数据结构DataFrame来表示表格式的数据，相比较于Numpy，Pandas可以存储混合的数据结构，同时使用NaN来表示缺失的数据，而不用像Numpy一样要手工处理缺失的数据，并且Pandas使用轴标签来表示行和列
Pandas使用函数read_csv()来读取csv文件
import&pandas
food_info&=&('food_info.csv')
int(type(food_info))
#&输出：&class&'pandas.core.frame.DataFrame'&&可见读取后变成一个DataFrame变量
该文件的内容如下：
使用函数head( m )来读取前m条数据，如果没有参数m，默认读取前五条数据
first_rows&=&food_info.head()
first_rows&=&food_info.head(3)
由于DataFrame包含了很多的行和列，
Pandas使用省略号（...）来代替显示全部的行和列，可以使用colums属性来显示全部的列名
print(food_info.columns)
# 输出：输出全部的列名，而不是用省略号代替
Index(['NDB_No',&'Shrt_Desc',&'Water_(g)',&'Energ_Kcal',&'Protein_(g)',&'Lid_Tot_(g)',&'Ash_(g)',&'Carbohydrt_(g)',&'Fiber_TD_(g)',&'Sugar_Tot_(g)',&'Calcium_(mg)',&'Iron_(mg)',&'Magnesium_(mg)',&'Phosphorus_(mg)',&'Potassium_(mg)',&'Sodium_(mg)',&'Zinc_(mg)',&'Copper_(mg)',&'Manganese_(mg)',&'Selenium_(mcg)',&'Vit_C_(mg)',&'Thiamin_(mg)',&'Riboflavin_(mg)',&'Niacin_(mg)',&'Vit_B6_(mg)',&'Vit_B12_(mcg)',&'Vit_A_IU',&'Vit_A_RAE',&'Vit_E_(mg)',&'Vit_D_mcg',&'Vit_D_IU',&'Vit_K_(mcg)',&'FA_Sat_(g)',&'FA_Mono_(g)',&'FA_Poly_(g)',&'Cholestrl_(mg)'],&dtype='object')
可以使用tolist()函数转化为list
food_info.columns.tolist()
与Numpy一样，用shape属性来显示数据的格式
dimensions = food_info.shapeprint(dimensions)
print(dimensions)
输出：(8618,36)&，
其中dimensions[0]为8618，dimensions[1]为36
与Numpy一样，用dtype属性来显示数据类型，Pandas主要有以下几种dtype：
object -- 代表了字符串类型
int -- 代表了整型
float -- 代表了浮点数类型
datetime -- 代表了时间类型
bool -- 代表了布尔类型
当读取了一个文件之后，Pandas会通过分析值来推测每一列的数据类型
输出：每一列对应的数据类型
NDB_No&&&&&&&&&&& int64
Shrt_Desc&&&&&&&&&& object
Water_(g)&&&&&&&&&& float64
Energ_Kcal&&&&&&&&& int64
Protein_(g)&&&&&&&&& float64
读取了文件后，Pandas会把文件的一行作为列的索引标签，使用行数字作为行的索引标签
注意，行标签是从数字0开始的
Pandas使用Series数据结构来表示一行或一列的数据，类似于Numpy使用向量来表示数据。Numpy只能使用数字来索引，而Series可以使用非数字来索引数据，当你选择返回一行数据的时候，Series并不仅仅返回该行的数据，同时还有每一列的标签的名字。
譬如要返回文件的第一行数据，Numpy就会返回一个列表（但你可能不知道每一个数字究竟代表了什么）
而Pandas则会同时把每一列的标签名返回（此时就很清楚数据的意思了）
Pandas使用loc[]方法来选择行的数据
#&选择单行数据：
food_info.loc[0]&&&#&选择行标号为0的数据，即第一行数据
food_info.loc[6]&&&#&选择行标号为6的数据，即第七行数据
#&选择多行数据：
food_info.loc[3:6]&#&使用了切片，注意：由于这里使用loc[]函数，所以返回的是行标号为3，4，5，6的数据，与python的切片不同的是这里会返回最后的标号代表的数据，但也可以使用python的切片方法：food_info[3:7]
food_info.loc[[2,5,10]]&#&返回行标号为2，5，10三行数据
练习：返回文件的最后五行
length&=&food_info.shape[0]
last_rows&=&food_info.loc[length-5:length-1]
num_rows&=&food_info.shape[0]
last_rows&=&food_info[num_rows-5:num_rows]
Pandas直接把列名称填充就能返回该列的数据
ndb_col&=&food_info[&NDB_No&]&#&返回列名称为NDB_No的那一列的数据
zinc_copper&=&food_info[[&Zinc_(mg)&,&&Copper_(mg)&]]&#&返回两列数据
现在要按照如下公式计算所有食物的健康程度，并按照降序的方式排列结果：
Score=2×(Protein_(g))-0.75×(Lipid_Tot_(g))
对DataFrame中的某一列数据进行算术运算，其实是对该列中的所有元素进行逐一的运算，譬如：
water_energy = food_info[&Water_(g)&] * food_info[&Energ_Kcal&]
由于每一列的数据跨度太大，有的数据是从0到100000，而有的数据是从0到10，所以为了尽量减少数据尺度对运算结果的影响，采取最简单的方法来规范化数据，那就是将每个数值都除以该列的最大值，从而使所有数据都处于0和1之间。其中max()函数用来获取该列的最大值.
food_info['Normalized_Protein']&=&food_info['Protein_(g)']&/&food_info['Protein_(g)'].max()
food_info['Normalized_Fat']&=&food_info['Lipid_Tot_(g)']&/&food_info['Lipid_Tot_(g)'].max()
food_info['Norm_Nutr_Index']&=&food_info[&Normalized_Protein&]&*&2&-&food_info[&Normalized_Fat&]&*&0.75
注意：上面的两个语句已经在原来的DataFrame中添加了三列，列名分别为Normalized_Protein和Normalized_Fat，Norm_Nutr_Index。只需要使用中括号和赋值符就能添加新列，类似于字典
对DataFrame的某一列数据排序，只需要使用函数sort()即可
food_info.sort(&Sodium_(mg)&)&#&函数参数为列名，默认是按照升序排序，同时返回一个新的
DataFramefood_info.sort(&Norm_Nutr_Index&,&inplace=True,&ascending=False&)&
#&通过inplace参数来控制在原表排序，而不是返回一个新的对象；ascending参数用来控制是否升序排序
import pandas as pd
read_csv()
读写csv数据
df =&pd.read_csv(path):
读入csv文件，形成一个数据框(data.frame)
df = pd.read_csv(path,&header=None)&不要把第一行作为header
* 注意，默认会将第一行作为header，并且默认会添加index，所以不需要的话需要手动禁用 *
df.to_csv(path, header=False, index=False)
数据框操作
df.head(1) 读取头几条数据
df.tail(1) 读取后几条数据
df[‘date’] 获取数据框的date列
df.head(1)[‘date’] 获取第一行的date列
df.head(1)[‘date’][0] 获取第一行的date列的元素值
sum(df[‘ability’]) 计算整个列的和
df[df[‘date’] == ‘’] 获取符合这个条件的行
df[df[‘date’] == ‘’].index[0] 获取符合这个条件的行的行索引的值
df.iloc[1] 获取第二行
df.iloc[1][‘test2’] 获取第二行的test2值
10 mins to pandas&
df.index 获取行的索引
df.index[0] 获取第一个行索引
df.index[-1] 获取最后一个行索引,只是获取索引值
df.columns 获取列标签
df[0:2] 获取第1到第2行，从0开始，不包含末端
df.loc[1] 获取第二行
df.loc[:,’test1’] 获取test1的那一列,这个冒号的意思是所有行，逗号表示行与列的区分
df.loc[:,[‘test1’,’test2’]] 获取test1列和test2列的数据
df.loc[1,[‘test1’,’test2’]] 获取第二行的test1和test2列的数据
df.at[1,’test1’] 表示取第二行，test1列的数据，和上面的方法类似
df.iloc[0] 获取第一行
df.iloc[0:2,0:2] 获取前两行前两列的数据
df.iloc[[1,2,4],[0,2]] 获取第1，2，4行中的0，2列的数据
(df[2] & 1).any() 对于Series应用any()方法来判断是否有符合条件的
一、&&&&&&&&&&&&创建对象
可以通过&Data Structure
Intro Setion&来查看有关该节内容的详细信息。
1、可以通过传递一个list对象来创建一个Series，pandas会默认创建整型索引：
2、通过传递一个numpy array，时间索引以及列标签来创建一个DataFrame：
3、通过传递一个能够被转换成类似序列结构的字典对象来创建一个DataFrame：
4、查看不同列的数据类型：
5、如果你使用的是IPython，使用Tab自动补全功能会自动识别所有的属性以及自定义的列，下图中是所有能够被自动识别的属性的一个子集：
二、&&&&&&&&&&&&查看数据
详情请参阅：Basics Section
1、&&查看frame中头部和尾部的行：
2、&&显示索引、列和底层的numpy数据：
3、&&describe()函数对于数据的快速统计汇总：
4、&&对数据的转置：
5、&&按轴进行排序
6、&&按值进行排序
三、&&&&&&&&&&&&选择
虽然标准的Python/Numpy的选择和设置表达式都能够直接派上用场，但是作为工程使用的代码，我们推荐使用经过优化的pandas数据访问方式：&.at,&.iat,&.loc,&.iloc&和&.ix详情请参阅Indexing
and Selecing Data&和&MultiIndex
/ Advanced Indexing。
1、&选择一个单独的列，这将会返回一个Series，等同于df.A：
2、&通过[]进行选择，这将会对行进行切片
l&&通过标签选择
1、&使用标签来获取一个交叉的区域
2、&通过标签来在多个轴上进行选择
3、&标签切片
4、&对于返回的对象进行维度缩减
5、&获取一个标量
6、&快速访问一个标量（与上一个方法等价）
l&&通过位置选择
1、&通过传递数值进行位置选择（选择的是行）
2、&通过数值进行切片，与numpy/python中的情况类似
3、&通过指定一个位置的列表，与numpy/python中的情况类似
4、&对行进行切片
5、&对列进行切片
6、&获取特定的值
l&&布尔索引
1、&使用一个单独列的值来选择数据：
2、&使用where操作来选择数据：
3、&使用isin()方法来过滤：
1、&设置一个新的列：
2、&通过标签设置新的值：
3、&通过位置设置新的值：
4、&通过一个numpy数组设置一组新值：
上述操作结果如下：
5、&通过where操作来设置新的值：
四、&&&&&&&&&&&&缺失值处理
在pandas中，使用np.nan来代替缺失值，这些值将默认不会包含在计算中，详情请参阅：Missing
Data Section。
1、&&reindex()方法可以对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝：、
2、&&去掉包含缺失值的行：
3、&&对缺失值进行填充：
4、&&对数据进行布尔填充：
五、&&&&&&&&&&&&相关操作
详情请参与&Basic
Section On Binary Ops
统计（相关操作通常情况下不包括缺失值）
1、&&执行描述性统计：
2、&&在其他轴上进行相同的操作：
3、&&对于拥有不同维度，需要对齐的对象进行操作。Pandas会自动的沿着指定的维度进行广播：
1、&&对数据应用函数：
具体请参照：Histogramming
and Discretization
字符串方法
Series对象在其str属性中配备了一组字符串处理方法，可以很容易的应用到数组中的每个元素，如下段代码所示。更多详情请参考：Vectorized
String Methods.
六、&&&&&&&&&&&&合并
Pandas提供了大量的方法能够轻松的对Series，DataFrame和Panel对象进行各种符合各种逻辑关系的合并操作。具体请参阅：Merging
Join&类似于SQL类型的合并，具体请参阅：Database
style joining
Append&将一行连接到一个DataFrame上，具体请参阅Appending：
七、&&&&&&&&&&&&分组
对于”group by”操作，我们通常是指以下一个或多个操作步骤：
（Splitting）按照一些规则将数据分为不同的组；
（Applying）对于每组数据分别执行一个函数；
（Combining）将结果组合到一个数据结构中；
详情请参阅：Grouping
1、&&分组并对每个分组执行sum函数：
2、&&通过多个列进行分组形成一个层次索引，然后执行函数：
八、&&&&&&&&&&&&Reshaping
详情请参阅&Hierarchical
Indexing&和&Reshaping。
数据透视表，详情请参阅：Pivot
可以从这个数据中轻松的生成数据透视表：
九、&&&&&&&&&&&&时间序列
Pandas在对频率转换进行重新采样时拥有简单、强大且高效的功能（如将按秒采样的数据转换为按5分钟为单位进行采样的数据）。这种操作在金融领域非常常见。具体参考：Time
Series section。
1、&&时区表示：
2、&&时区转换：
3、&&时间跨度转换：
4、&&时期和时间戳之间的转换使得可以使用一些方便的算术函数。
十、&&&&&&&&&&&&Categorical
从0.15版本开始，pandas可以在DataFrame中支持Categorical类型的数据，详细&介绍参看：categorical
introduction和API
documentation。
1、&&将原始的grade转换为Categorical数据类型：
2、&&将Categorical类型数据重命名为更有意义的名称：
3、&&对类别进行重新排序，增加缺失的类别：
4、&&排序是按照Categorical的顺序进行的而不是按照字典顺序进行：
5、&&对Categorical列进行排序时存在空的类别：
十一、&&&&&&&&&&&画图
具体文档参看：Plotting&docs
对于DataFrame来说，plot是一种将所有列及其标签进行绘制的简便方法：
十二、&&&&&&&&&&&导入和保存数据
CSV，参考：Writing
to a csv file
1、&&写入csv文件：
2、&&从csv文件中读取：
HDF5，参考：HDFStores
1、&&写入HDF5存储：
2、&&从HDF5存储中读取：
，参考：MS
1、&&写入excel文件：
2、&&从excel文件中读取：
优质网站模板Python数据分析入门之pandas基础总结-爱编程
Python数据分析入门之pandas基础总结
Pandas--“大熊猫”基础
Series: pandas的长枪(数据表中的一列或一行,观测向量,一维数组...)
Series1 = pd.Series(np.random.randn(4))
print Series1,type(Series1)
print Series1.index
print Series1.values
输出结果：
dtype: float64 &class 'pandas.core.series.Series'&
Int64Index([0, 1, 2, 3], dtype='int64')
np.random.randn() 正态分布相关。
Series?持过滤的原理就如同NumPy
print Series1&0
print Series1[Series1&0]
输出结果如下：
0 0.030480
1 0.072746
2 -0.186607
3 -1.412244
dtype: float64 &class 'pandas.core.series.Series'&
Int64Index([0, 1, 2, 3], dtype='int64')
我发现，逻辑表达式，获得的值就是True或者False。要先取得值，还是要X[y]的形式。
当然也支持广播Broadcasting
什么是broadcasting,暂时我也不太清楚，看个栗子：
print Series1*2
print Series1+5
输出结果如下：
1 1 0.145492
2 -0.373215
3 -2.824489
dtype: float64
0 5.030480
1 5.072746
2 4.813393
3 3.587756
dtype: float64
以及Universal Function
numpy.frompyfunc(out,nin,nout) 返回的是一个函数，nin是输入的参数个数，nout是函数返回的对象的个数
在序列上就使用行标，而不是创建1个2列的数据表，能够轻松辨别哪是数据，哪是元数据
这句话的意思，我的理解是序列尽量是一列，不用去创建2列，这样子，使用index就能指定数据了
Series2 = pd.Series(Series1.values,index=['norm_'+unicode(i) for i in xrange(4)])
print Series2,type(Series2)
print Series2.index
print type(Series2.index)
print Series2.values
输出结果如下，可以看到，它是通过修改了index值的样式，并没有创建2列。
dtype: float64 &class 'pandas.core.series.Series'&
Index([u'norm_0', u'norm_1', u'norm_2', u'norm_3'], dtype='object')
&class 'pandas.core.index.Index'&
虽然行是有顺序的，但是仍然能够通过行级的index来访问到数据：
（当然也不尽然像Ordered Dict，因为?索引甚?可以重复，不推荐重复的行索引不代表不能用）
print Series2[['norm_0','norm_3']]
可以看到，读取数据时，确实要采用X[y]的格式。这里X[[y]]是因为，它要读取两个数据，指定的是这两个数据的index值，将index值存放进list中，然后读取。输出结果如下：
dtype: float64
print 'norm_0' in Series2
print 'norm_6' in Series2
输出结果：
逻辑表达式的输出结果，布尔型值。
从Key不重复的Ordered Dict或者从Dict来定义Series就不需要担心行索引重复：
Series3_Dict = {&Japan&:&Tokyo&,&S.Korea&:&Seoul&,&China&:&Beijing&}
Series3_pdSeries = pd.Series(Series3_Dict)
print Series3_pdSeries
print Series3_pdSeries.values
print Series3_pdSeries.index
输出结果：
China Beijing
Japan Tokyo
S.Korea Seoul
dtype: object
['Beijing' 'Tokyo' 'Seoul']
Index([u'China', u'Japan', u'S.Korea'], dtype='object')
通过上面的输出结果就知道了，输出结果是无序的，和输入顺序无关。
想让序列按你的排序?式保存？就算有缺失值都毫无问题
Series4_IndexList = [&Japan&,&China&,&Singapore&,&S.Korea&]
Series4_pdSeries = pd.Series( Series3_Dict ,index = Series4_IndexList)
print Series4_pdSeries
print Series4_pdSeries.values
print Series4_pdSeries.index
print Series4_pdSeries.isnull()
print Series4_pdSeries.notnull()
上面这样的输出就会按照list中定义的顺序输出结果。
整个序列级别的元数据信息：name
当数据序列以及index本身有了名字，就可以更方便的进行后续的数据关联啦！
这里我感觉就是列名的作用。下面举例：
print Series4_pdSeries.name
print Series4_pdSeries.index.name
很显然，输出的结果都是None，因为我们还没指定name嘛！
Series4_pdSeries.name = &Capital Series&
Series4_pdSeries.index.name = &Nation&
print Series4_pdSeries
输出结果：
Japan Tokyo
China Beijing
Singapore NaN
S.Korea Seoul
Name: Capital Series, dtype: object
&字典&？不是的，?index可以重复，尽管不推荐。
Series5_IndexList = ['A','B','B','C']
Series5 = pd.Series(Series1.values,index = Series5_IndexList)
print Series5
print Series5[['B','A']]
输出结果：
A 0.030480
B 0.072746
B -0.186607
C -1.412244
dtype: float64
B 0.072746
B -0.186607
A 0.030480
dtype: float64
我们可以看出，Series['B']输出了两个值，所以index值尽量不要重复呀！
DataFrame：pandas的战锤(数据表，?维数组)
Series的有序集合，就像R的DataFrame一样方便。
仔细想想，绝大部分的数据形式都可以表现为DataFrame。
从NumPy二维数组、从文件或者从数据库定义：数据虽好，勿忘列名
dataNumPy = np.asarray([('Japan','Tokyo',4000),('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF1 = pd.DataFrame(dataNumPy,columns=['nation','capital','GDP'])
这里DataFrame中的columns应该就是列名的意思。现在看print的结果，是不是很舒服啊！Excel的样式嘛
等长的列数据保存在一个字典里（JSON）：很不幸，字典key是无序的
dataDict = {'nation':['Japan','S.Korea','China'],'capital':['Tokyo','Seoul','Beijing'],'GDP':[00]}
DF2 = pd.DataFrame(dataDict)
输出结果可以发现，无序的！
GDP capital nation
Beijing China
PS:由于懒得截图放过来，这里没有了边框线。
从另一个DataFrame定义DataFrame：啊，强迫症犯了！
DF21 = pd.DataFrame(DF2,columns=['nation','capital','GDP'])
很明显，这里是利用DF2定义DF21，还通过指定cloumns改变了列名的顺序。
DF22 = pd.DataFrame(DF2,columns=['nation','capital','GDP'],index = [2,0,1])
很明显，这里定义了columns的顺序，还定义了index的顺序。
nation capital GDP
2 China Beijing 9100
0 Japan Tokyo 4900
1 S.Korea Seoul 1300
从DataFrame中取出列？两种方法（与JavaScript完全一致！）
OMG，囧，我竟然都快忘了js语法了，现在想起了，但是对象的属性既可以obj.x也可以obj[x]。
'.'的写法容易与其他预留关键字产生冲突
'[ ]'的写法最安全。
从DataFrame中取出行？（至少）两种?法：
方法1和方法2：
print DF22[0:1] #给出的实际是DataFrame
print DF22.ix[0] #通过对应Index给出?,**ix**好爽。
输出结果：
Name: 0, dtype: object
方法3 像NumPy切片一样的终极招式：iloc
print DF22.iloc[0,:]
#第一个参数是第几行，第二个参数是列。这里呢，就是第0行，全部列
print DF22.iloc[:,0]
#根据上面的描述，这里是全部行，第0列
输出结果，验证一下：
Name: 2, dtype: object
Name: nation, dtype: object
动态增加列列，但是无法用&.&的方式，只能用&[]&
举个栗子说明一下就明白了：
DF22['population'] = []
输出结果：
capital GDP population
Beijing 9100
S.Korea Seoul
Index：行级索引
Index：pandas进?数据操纵的鬼牌（行级索引）
?级索引是：
可能由真实数据产生，因此可以视作数据
可以由多重索引也就是多个列组合而成
可以和列名进行交换，也可以进行堆叠和展开，达到Excel透视表效果
Index有四种...哦不，很多种写法，?些重要的索引类型包括：
pd.Index（普通）
Int64Index（数值型索引）
MultiIndex（多重索引，在数据操纵中更详细描述）
DatetimeIndex（以时间格式作为索引）
PeriodIndex （含周期的时间格式作为索引）
直接定义普通索引，长得就和普通的Series?样
index_names = ['a','b','c']
Series_for_Index = pd.Series(index_names)
print pd.Index(index_names)
print pd.Index(Series_for_Index)
输出结果：
Index([u'a', u'b', u'c'], dtype='object')
Index([u'a', u'b', u'c'], dtype='object')
可惜Immutable，牢记！ 不可变！举例如下：此处挖坑啊。不明白……
index_names = ['a','b','c']
index0 = pd.Index(index_names)
print index0.get_values()
index0[2] = 'd'
输出结果如下：
['a' 'b' 'c']
---------------------------------------------------------------------------
Traceback (most recent call last)
&ipython-input-36-f34da0a8623c& in &module&()
2 index0 = pd.Index(index_names)
3 print index0.get_values()
----& 4 index0[2] = 'd'
C:\Anaconda\lib\site-packages\pandas\core\index.pyc in __setitem__(self, key, value)
def __setitem__(self, key, value):
raise TypeError(&Indexes does not support mutable operations&)
def __getitem__(self, key):
TypeError: Indexes does not support mutable operations
扔进去一个含有多元组的List，就有了MultiIndex
可惜，如果这个List Comprehension改成小括号，就不对了。
multi1 = pd.Index([('Row_'+str(x+1),'Col_'+str(y+1)) for x in xrange(4) for y in xrange(4)])
multi1.name = ['index1','index2']
print multi1
输出结果：
MultiIndex(levels=[[u'Row_1', u'Row_2', u'Row_3', u'Row_4'], [u'Col_1', u'Col_2', u'Col_3', u'Col_4']],
labels=[[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]])
对于Series来说，如果拥有了多重Index，数据，变形！
下列代码说明：
二重MultiIndex的Series可以unstack()成DataFrame
DataFrame可以stack成拥有?重MultiIndex的Series
data_for_multi1 = pd.Series(xrange(0,16),index=multi1)
data_for_multi1
输出结果：
dtype: int32
看到输出结果，好像明白了点，有点类似Excel汇总一样。不过，日后还得查点
二重MultiIndex的Series可以unstack()成DataFrame
data_for_multi1.unstack()
DataFrame可以stack成拥有?重MultiIndex的Series
data_for_multi1.unstack().stack()
输出结果：
dtype: int32
非平衡数据的例子：
multi2 = pd.Index([('Row_'+str(x+1),'Col_'+str(y+1)) for x in xrange(5) for y in xrange(x)])
输出结果：
MultiIndex(levels=[[u'Row_2', u'Row_3', u'Row_4', u'Row_5'], [u'Col_1', u'Col_2', u'Col_3', u'Col_4']],
labels=[[0, 1, 1, 2, 2, 2, 3, 3, 3, 3], [0, 0, 1, 0, 1, 2, 0, 1, 2, 3]])
data_for_multi2 = pd.Series(np.arange(10),index = multi2) data_for_multi2
输出结果：
dtype: int32
import datetime
dates = [datetime.datetime(),datetime.datetime(),datetime.datetime()]
pd.DatetimeIndex(dates)
输出结果：
DatetimeIndex(['', '', ''], dtype='datetime64[ns]', freq=None, tz=None)
如果你不仅需要时间格式统一，时间频率也要统一的话
periodindex1 = pd.period_range(';,';,freq='M')
print periodindex1
输出结果：
PeriodIndex([';, ';, ';, ';], dtype='int64', freq='M')
月级精度和日级精度如何转换？
有的公司统?以1号代表当月，有的公司统一以最后1天代表当?，转化起来很麻烦，可以asfreq
print periodindex1.asfreq('D',how='start')
print periodindex1.asfreq('D',how='end')
输出结果：
PeriodIndex(['', '', '', ''], dtype='int64', freq='D')
PeriodIndex(['', '', '', ''], dtype='int64', freq='D')
最后的最后，我要真正把两种频率的时间精度匹配上？
periodindex_mon = pd.period_range(';,';,freq='M').asfreq('D',how='start')
periodindex_day = pd.period_range('','',freq='D')
print periodindex_mon
print periodindex_day
输出结果：
PeriodIndex(['', '', ''], dtype='int64', freq='D')
PeriodIndex(['', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', '', '', '',
'', ''],
dtype='int64', freq='D')
粗粒度数据＋reindex＋ffill/bfill
full_ts = pd.Series(periodindex_mon,index=periodindex_mon).reindex(periodindex_day,method='ffill')
关于索引，?便的操作有？
前?描述过了，索引有序，重复，但?定程度上?能通过key来访问，也就是说，某些集合操作都是可以?持的。
index1 = pd.Index(['A','B','B','C','C'])
index2 = pd.Index(['C','D','E','E','F'])
index3 = pd.Index(['B','C','A'])
print index1.append(index2)
print index1.difference(index2)
print index1.intersection(index2)
print index1.union(index2) # Support unique-value Index well
print index1.isin(index2)
print index1.delete(2)
print index1.insert(0,'K') # Not suggested
print index3.drop('A') # Support unique-value Index well
print index1.is_monotonic,index2.is_monotonic,index3.is_monotonic
print index1.is_unique,index2.is_unique,index3.is_unique
输出结果：
Index([u'A', u'B', u'B', u'C', u'C', u'C', u'D', u'E', u'E', u'F'], dtype='object')
Index([u'A', u'B'], dtype='object')
Index([u'C', u'C'], dtype='object')
Index([u'A', u'B', u'B', u'C', u'C', u'D', u'E', u'E', u'F'], dtype='object')
[False False False
Index([u'A', u'B', u'C', u'C'], dtype='object')
Index([u'K', u'A', u'B', u'B', u'C', u'C'], dtype='object')
Index([u'B', u'C'], dtype='object')
True True False
False False True
大熊猫世界来去自如：Pandas的I/O
老生常谈，从基础来看，我们仍然关心pandas对于与外部数据是如何交互的。
结构化数据输入输出
read_csv与to_csv 是?对输?输出的?具，read_csv直接返回pandas.DataFrame，?to_csv只要执行命令即可写文件
read_table：功能类似
read_fwf：操作fixed width file
read_excel与to_excel方便的与excel交互
header 表?数据中是否存在列名，如果在第0行就写就写0，并且开始读数据时跳过相应的行数，不存在可以写none
names 表示要用给定的列名来作为最终的列名
encoding 表?数据集的字符编码，通常而言一份数据为了?便的进??件传输都以utf-8作为标准
这里用的是自己的一个csv数据，因为找不到参考的这个pdf中的数据。
cnames=['经度','纬度']
taxidata2 = pd.read_csv('.csv',header = 4,names=cnames,encoding='utf-8')
全部参数的请移步API：
这里介绍一些常用的参数：
读取处理：
skiprows：跳过?定的?数
nrows：仅读取?定的?数
skipfooter：尾部有固定的?数永不读取
skip_blank_lines：空?跳过
内容处理：
sep/delimiter：分隔符很重要，常?的有逗号，空格和Tab('\t')
na_values：指定应该被当作na_values的数值
thousands：处理数值类型时，每千位分隔符并不统? (1.234.567,89或者1,234,567.89都可能)，此时要把字符串转化为
数字需要指明千位分隔符
收尾处理：
index_col：将真实的某列（列的数?，甚?列名）当作index
squeeze：仅读到?列时，不再保存为pandas.DataFrame?是pandas.Series
Excel ... ?
对于存储着极为规整数据的Excel而言，其实是没必要一定用Excel来存，尽管Pandas也十分友好的提供了I/O接口。
taxidata.to_excel('t0401.xlsx',encoding='utf-8')
taxidata_from_excel = pd.read_excel('t0401.xlsx',header=0, encoding='utf-8')
taxidata_from_excel
注意：当你的xls文件行数很多超过65536时，就会遇到错误，解决办法是将写入的格式变为xlsx。
唯一重要的参数：sheetname=k，标志着一个excel的第k个sheet页将会被取出。（从0开始）
半结构化数据
JSON：网络传输中常?的?种数据格式。
仔细看一下，实际上这就是我们平时收集到异源数据的风格是一致的：
列名不能完全匹配
key可能并不唯一
元数据被保存在数据里
import json
json_data = [{'name':'Wang','sal':50000,'job':'VP'},\
{'name':'Zhang','job':'Manager','report':'VP'},\
{'name':'Li','sal':5000,'report':'IT'}]
data_employee = pd.read_json(json.dumps(json_data))
data_employee_ri = data_employee.reindex(columns=['name','job','sal','report'])
data_employee_ri
输出结果：
深入Pandas数据操纵
在前面部分的基础上，数据会有更多种操纵方式：
通过列名、行index来取数据，结合ix、iloc灵活的获取数据的一个子集（第一部分已经介绍）
按记录拼接（就像Union All）或者关联（join）
方便的统计函数与?定义函数映射
缺失值处理
与Excel一样灵活的数据透视表（在第四部分更详细介绍）
数据集整合
横向拼接：直接DataFrame
pd.DataFrame([np.random.rand(2),np.random.rand(2),np.random.rand(2)],columns=['C1','C2'])
横向拼接：Concatenate
pd.concat([data_employee_ri,data_employee_ri,data_employee_ri])
### 纵向拼接：Merge
根据数据列关联，使用on关键字
可以指定一列或多列
可以使?left_on和right_on
pd.merge(data_employee_ri,data_employee_ri,on='name')
根据index关联，可以直接使用left_index和right_index
TIPS: 增加how关键字，并指定
how = 'inner'
how = 'left'
how = 'right'
how = 'outer'
结合how，可以看到merge基本再现了SQL应有的功能，并保持代码整洁
自定义函数映射
dataNumPy32 = np.asarray([('Japan','Tokyo',4000),('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF32 = pd.DataFrame(dataNumPy32,columns=['nation','capital','GDP'])
map: 以相同规则将1列数据作1个映射，也就是进行相同函数的处理
def GDP_Factorize(v):
fv = np.float64(v)
if fv & 6000.0:
return 'High'
elif fv & 2000.0:
return 'Low'
return 'Medium'
DF32['GDP_Level'] = DF32['GDP'].map(GDP_Factorize)
DF32['NATION'] = DF32.nation.map(str.upper)
sort: 按?列或者多列的值进行行级排序
sort_index: 根据index?的取值进行排序，而且可以根据axis决定是重排行还是列
dataNumPy33 = np.asarray([('Japan','Tokyo',4000),('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF33 = pd.DataFrame(dataNumPy33,columns=['nation','capital','GDP'])
DF33.sort(['capital','nation'],ascending=False)
ascending是降序的意思。
sort_index
DF33.sort_index(axis=1,ascending=True)
一个好用的功能：Rank
DF33.rank()
缺失数据处理
忽略缺失值：
DF34.mean(skipna=True)
不忽略缺失值的话，估计就不能计算均值了吧。
如果不想忽略缺失值的话，就需要祭出fillna了：
注：这里我在猜想，axis=1是不是就代表从行的角度呢？还是得多读书查资料呀。
“一组”大熊猫：Pandas的groupby
groupby的功能类似SQL的group by关键字：
Split-Apply-Combine
Split，就是按照规则分组
Apply，通过?定的agg函数来获得输?pd.Series返回?个值的效果
Combine，把结果收集起来
Pandas的groupby的灵活性：
分组的关键字可以来?于index，也可以来?于真实的列数据
分组规则可以通过?列或者多列
没有具体数据，截图看一下吧，方便日后回忆。
分组可以快速实现MapReduce的逻辑
Map: 指定分组的列标签，不同的值就会被扔到不同的分组处理
Reduce: 输入多个值，返回1个值，一般可以通过agg实现，agg能接受1个函数
S1EP3_Pandas.pdf 不知道什么时候存到电脑里的资料，今天发现了它。感谢作者的资料。
本文博客地址
创作，采用
进行许可。
可自由转载、引用，但需署名作者且注明文章出处。
版权所有 爱编程 (C) Copyright 2012. . All Rights Reserved.
闽ICP备号-3
微信扫一扫关注爱编程，每天为您推送一篇经典技术文章。