赵工的个人空间

数据处理，首先是数据获取问题，数据可来源于互联网，也可以来自硬件设备，或专业的公司。Python的pyserial与pyvisa支持RS-232、GPIB、USB接口，可用于硬件设备的数据采集。各种数据源提供的数据格式多种多样，常见的有文本格式、CSV格式、Excell文件，以及JSON、XML、HTML，还有数据库文件，甚至PDF文件和HDF文件。

一、数据格式：

1. JSON格式：

JSON是一种轻量级的数据交换格式，适合机器解析和生成。在Ajax中，JSON得到大量应用，很多网站的数据传输均采用JSON形式，很多编程语言也支持JSON解析。
Python标准库中支持JSON ，其他还有PYSON、Yajl-Py、ultrajson、metamagic.json等软件包。Python与JSON数据操作有编码encoding和解码decoding，对应函数主要是dump、dumps或load、loads。
1）simplejson：
simplejson是简单、快捷、可扩展的JSON编/解码器，以纯Python编写，但包含了可选的C扩展。需要使用pip进行安装。
dumps函数可将Python对象编码成JSON，实际返回的是字符串；loads函数可将JSON解码，输入字符串数据生成Python对象。示例：
from pprint import pprint
import simplejson as json
tup1=('red','greed','blue')
print(json.dumps(tup1)) # ['red','green','blue']
print9type(json.loads(json.dumps(tup1)))) # <type 'list'>
列表与JSON相互转换：
list1=[11,22,33]
print(type(json.dumps(list1))) # <type 'str'>
print(type(json.loads(json.dumps(list1)))) # <type 'list'>
dumps支持字典类型，并可以对字典排序：
student={'101':{'class':'V','Name':'Rohit','Roll_no':7},'102':{'class':'V','Name':'David','Roll_no':8}}
print(json.dumps(student, sort_keys=True))

2. XML：

XML为可扩展标记语言，可用来标记数据、定义数据类型。XML的标签是自定义的。
XML文档包含由起始和结束标记tag分隔的一个或多个元素element。文档必须包含根元素，该元素是所有其他元素的父元素，一个XML文档中只有一个根元素。元素可有属性，属性可有多个，是名字=值对，属性由空格分隔，在元素的起始标记中，属性名不能重复，属性值必须用引号包围起来，单引号、双引号均可。
Python附带了xml.dom.minidom和相关的pulldom以及SAX(Simple API for XML)模块，还会附带ElementTree API，还有一些第三方库可以提供更高级功能。
1）LXML库：
LXML库是对C语言的XML库libxml2与libxslt的Python封装，是XML的完整实现，其中收集了多款XML和HTML软件，如XPath、XSLT、lxml.objecttify、lxml.html、lxml.cssselect、Beautiful Soup、html5lib，从而可用于XML与HTML场合。LXML以包含在Anaconda中。

3. HDF5：

HDF5文件格式用于科学数据存储和发布，每个HDF文件都含有一个文件系统式的节点结构，能够存储多个数据集。HDF5支持多种压缩器的即时压缩，还能高效地存储重复模式数据，能分块读写，可将上TB的数据存储，对于非常大而无法直接放入内存的数据集很适合。
HDF5文件包含两种基本数据对象：
·群组group：类似于文件夹，可以包含多个数据集或下级群组
·数据集dataset：数据内容，可以是多维数组，也可以是复杂的数据类型
群组和数据集都支持元数据与属性。HDF5属性是一个用户自定义的HDF5接口，提供附加信息。数据集是数据元素的多维数组，同时支持元数据。要创建一个数据集，应用程序必须指明数据集的位置、数据集的名称、数据类型和数组的数据大小以及数据集的创建特性列表。
HDF5最适合一次写多次读的数据集，虽然数据可以在任何时候被添加到文件中，但如果发生多个写操作，文件就可能被破坏。
Python利用扩展包PyTables或h5py来访问HDF5库，h5py提供了一种直接而高级的HDF5 API访问接口，而PyTables则抽象了HDF5的许多细节以提供多种灵活的数据容器、表索引、查询功能，还能添加列索引以提升查询数据。PyTables已经包含在Anaconda中。
1）PyTables：
PyTables是基于HDF5与NumPy的Python扩展包，以磁盘存储结构形式处理超过内存大小的数据。PyTables以表和数组对象为分层结构存储数据，其中的表是指记录的集合，记录值存储成固定长度，所有记录有相同的结构和数据类型。PyTables使用专门类定义域和属性。
⑴声明列描述符，继承IsDescription：
class row_des(IsDescription):
    Date=tb.StringCol(26)
    No1=tb.IntCol()
    No2=tb.IntCol()
    No3=tb.Float64Col()
No4=tb.Float64Col()
其中定义了列以及类型。
⑵新建文件，定义了写属性以及描述字符串：
h5=tb.open_file('tab.h5','w',title='test pytable')
创建表，表格名为ints_flosts。PyTables表类似于NumPy的ndarray对象。
tab=h5.create_table('/','ints_floats',row_des,title='ingeters and floats',expectedrows=rows)
ran_int=np.random.randint(0,10000,size=(rows,2))
ran_flo=np.random.standard_normal((rows,2)).round(5)
⑶获取表实例的行实例指针：
pointer=tab.row
⑷使用类似字典的键值访问形式给表的行实例赋值，并通过flush函数将表的I/O缓冲区写入磁盘。
for i in range(rows):
    pointer['Date']=dt.datetime.now()
    pointer['No1']=ran_int[i,0]
    pointer['No2']=ran_int[i,1]
    pointer['No3']=ran_flo[i,0]
    pointer['No4']=ran_flo[i,1]
    pointer.append()
tab.flush()
⑸为了管理方便，可建立组，然后在组上建立表。
group=h5.create_group('/','hdf5_group','group information')
tab1=h5.create_table(group,'grouptable',row_des,title='group table')
row=rab1.row
for i in xrange(100):
    row['Data']=dt.datetime.now()
    row['No1']=ran_int[i,0]
    row['No2']=ran_int[i,1]
    row['No3']=ran_flo[i,0]
    row['No4']=ran_flo[i,1]
    row.append()
tab1.flush()
⑹除了组、表，PyTables还有数组。使用代码直接在PyTables的root中创建数组：
arr_int=hs.screate_array('/','integers',ran_int)
arr_flo=h5.create_array('/','floats',ran_flo)
⑺PyTables内的表、数组访问形式是通过下标访问：
print(tab[:3])
print(h5.root.ints_floats[:3])
print(h5.root.hdf5_group.grouptable[2]['Date'])
print(h5.root.integers[1:10])
for i in h5.root.integers:
    print(i)
PyTables的数据访问还支持类似SQL语句的形式，即where语句形式。同时PyTables还支持max()、min()、mean()等函数。Pandas中包含了PyTables软件。

二、Python内置函数生成随机数：

Python有一个随机数模块，可以实现基于各种统计分布的伪随机数生成器，包括均匀分布、正态分布、对数正态分布、负指数分布、伽马分布和贝塔分布等，可生成多种数据类型。
梅森旋转Mersenne Twister是Python的主要随机数生成器，能够生成53位精度的随机浮点数，周期达2**19937-1，且易于扩展和测试，其底层用C语言实现，但因为它是完全确定的，不适用安全相关计算。随机数模块还提供了SystemRandom类，用操作系统自带的os.urandom()函数生成随机数，可为加密目的生成随机数。
Python随机数模块中包括各种内置函数。

1. 基本函数：

·randomseed(a=None, version=2)：初始化随机数生成器，指定整数a，a就为初始值，缺省或值为None，就以系统时间做seed值。
·random.getstate()：返回一个表示随机数生成器当前内部状态的对象
·random.setstate(state)：状态值必须是从getstate()调用中获得的对象，用来恢复生成器的内部状态到random.getstate()被调用时的状态
·random.getrandbits(k)：返回一个长度为k位的随机长整型数据

2. 整型随机数生成函数：

·random.randrange(start, stop[, step])：返回给定范围内的整型随机数。start为范围起始值，缺省时从0开始；stop为范围终点，终点不包括在内；step表示相加的步长值，以确定随机数值。
·random.randint(a, b)：返回一个a到b范围内的整型值

3. 随机序列生成器函数：

·random.choice(seq)：返回一个非空的seq序列中的随机元素
·random.shuffle(x)：混合x序列中的所有元素，即打乱位置
·random.sample(population, k)：返回一个序列或集合中的k位长的唯一随机元素列表

4. 基于统计分布的函数：

·random.uniform(a, b)：返回[a, b}区间的一个随机浮点数，均匀分布
·random.triangular(low, high, mode)：返回服从low<=N<=high三角分布的一个随机浮点数，默认low为0，hight为1，mode为low和high的中点
·random.betavariate(alpha, beta)：返回[0,1)区间的贝塔分布随机数，两个参数大于0
·random.expovariate(lambd)：返回一个基于指数分布的随机数，lambd是非零值，值为正使，返回0至正无穷大区间的值；如果值为负，返回负无穷大到0区间的值
·random.gammavariate(alpha, beta)：返回基于伽马分布的随机数，两个参数大于0
·random.normalvariate(mu, sigma)：产生基于正态分布随机数，mu为均值，sigma为方差
·random.gauss(mu, sigma)：利用高斯分布生成随机数，mu为均值，sigma为方差，速度快
·random.lognormvariate(mu, sigma)：生成对数正态分布随机数，以自然数为底的此分布与正态分布等价，mu为均值，sigma为标准差，sigma要大于0
·random.vonmisesvariate(mu, kappa)：用冯·米塞斯分布返回随机角度值，mu为角度的均值，范围[0 2*pi)之间；kappa是浓度参数，要大于0
·random.paretovariate(alpha)：生成帕累托分布随机数，alpha是形状参数
·random.weibullvariate(alpha, beta)：返回Weibull分布随机数，alpha为标量参数，beta为形状参数

5. 不确定的随机数生成器：

·random.SystemRandom([seed])：用操作系统提供的os.urandom()函数生成随机数，用于密码学和安全领域

6. 自定义随机数生成器：

可以继承扩展Random类生成自定义分布的随机数生成器。也可以根据一些算法生成随机数值。比如生成泊松分布的随机数代码为：
import math
import random
def nextPoisson(lambdaValue):
    elambda=math.exp(-1*lambdaValue)
    product=1
    count=0
    while(product>=elambda):
        product*=random.random()
        result=count
        count+=1
    return result
for x in range(1, 9):
    print(nextPoisson(8))

三、statistics库：

statistics库提供了很多方法用于计算数值数据的数理统计信息。

1. 计算平均数函数mean()：

import statistics
statistics.mean([1,2,3,4,5,6,7,8,9])
statistics.mean(range(1,10))
import fractions
x=[(3,7),(1,21),(5,3),(1,3)]
y=[fractions.Fraction(*item) for item in x]
statistics.mean(y)
import decimal
x=('0.5','0.75','0.625','0.375')
y=map(decimal.Decimal, x)
statistics.mean(y)

2. 中位数函数median()、median_low()、median_high()、median_grouped()：

statistics.median([1,3,5,7])
statistics.median_low([1,3,5,7])
statistics.median_high([1,3,5,7])
statistics.median(range(1,10))
statistics.median_grouped([3,5,7])
statistics.median_grouped([52,52,53,54])
statistics.median_grouped([1,3,3,5,7])
statistics.median_grouped([1,2,2,3,4,4,4,4,4,5])
statistics.median_grouped([1,2,2,3,4,4,4,4,4,5],interval=2)

3. 返回最常见数据或出现次数最多的数据的函数mode()：

statistics.mode([1,3,5,7,3])

4. 返回总体标准差pstdev()：

statistics.pstdev([1.5,2.5,2.5,2.75,3.25,4.75])
statistics.pstdev(range(20))

5. 返回总体方差或二次矩pvariance()：

statistics.pvariance([1.5,2.5,2.5,2.75,3.25,4.75])
x=[1,2,3,4,5,10,9,8,7,6]
mu=statistics.mean(x)
statistics.pvariance([1,2,3,4,5,10,9,8,7,6],mu)
statistics.pvariance(range(20))
statistics.pvariance((random.randint(1,10000) for i in range(30)))

6. variance()、stdev()：

statistics.variance(range(20))
statistics.stdev(range(20))

四、pandas库：

pandas是Python Data Analysis Library的缩写，这是一种连接SciPy和NumPy的工具，目的是完成数据分析，适用于商务和科学领域。数据分析和数据处理包括加载、准备、操作、建模和分析五个步骤。pandas纳入了大量库和一些标准的数据模式，能够高效地操作大型数据集，能读取多种文件格式，包括CSV、HDF5，目前成为Python数据处理标准工具。
pandas的数据结构采用自动的或明确的数据对齐的、带有标签轴的形式，可以防止由数据不对齐引起的常见错误，并可以处理不同来源的不同索引数据。
pandas有为Python数据结构增加了三个数据类型，Series、DataFrame和Panel，Panel是三维的数据结构，通常是同一个组织或人的多个时间周期的多项数据。Panel数据结构有三个组成部分，项目item、主轴major axis和次轴minor axis，item指的是Panel中每个DataFrame的数据项；major axis指的是每个DataFrame的索引，即行标签；minor axis指的是每个DataFrame的列。不过这种数据结构已被废弃。
pandas包含在Anaconda中。

1. pandas的Series：

Series是一种类似一维数组的对象，由一组数据和相应的索引组成，可以存储任意Python数据类型，包括整型、浮点数、字符串以及Python对象。Series的每一个项目还有一个标签索引，默认情况下索引从0到N表示N+1个项目。Series可通过NumPy的ndarray、Python的字典以及常量数据创建，可以为Series数据设置对应索引。基本用法：
import pandas as pd
ser=pd.Series(data, index=index)
下面是用三种常见方式创建Series对象的示例：
s0=pd.Series(np.random.randn(10))
s1=pd.Series(np.random.randn(4), name='Series data', index=list('ABCD'))    # 指定索引
s2=pd.Series({'A':1,'B':2,'C':3,'D':4})
s4=pd.Series(4,index=list('ABCD'))
其中，s0和s1是通过NumPy的ndarray创建的，但Series支持索引；s2是通过字典形式创建的。访问Series，既可采用整数下标方式，也可以采用类似字典的键方式。
s0[0]
s1['A']
Series的访问方式除了索引方式，还有切片方式。对于数字型的索引，与Python列表相同：
s0[0:5]
但对于指定的索引，即s1,s2,s3方式，包含末尾的索引值：
s1['A':'C']

2. DataFrame的创建：

DataFrame是一个二维数据，行具有索引，列可能由不同的数据类型构成。可将DataFrame看作表格或Series对象的字典。
通过列表、Series字典、列表字典生成DataFrame数据的示例：
import pandas as pd
import numpy as np
df0=pd.DataFrame([[10,20,30,40],[23,34,45,56],[7,8,9],[9,7,5],[1,2,3]],
columns=['column1','column2','column3','column4'],index=['a','b','c','d','e'])
d={'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([4,5,6,7],index=['a','b','c','d'])}
df1=pd.DataFrame(d)
df2=pd.DataFrame([{'a':1,'b':2,'c':3},{'a':2,'b':1},{'c':1}])    #字典列表
df3=pd.DataFrame({'a':[1,3,5,7,},'b':[2,4,6,8,]})
df4=pd.DataFrame(np.arange(30).reshape(5,6),
index=['index1','index2','index3','index4','index5'],columns=list('abcdef'))
代码中，df0、df1、df2包含了NaN数据，表示数据缺失，pandas提供了isnull()、dropna()、fillna()方法，分别用于判断、过滤、填充缺失数据。

3. DataFrame的索引访问：

对DataFrame执行[]操作符可以返回相应的列，传递给[]的参数可以是一个对象或者一个列表数据，返回的数据类型可能是Series或者原DataFrame的子集。
df4['a']
df4[['a','b','c']]
df4.a
af4[[1,5]]
上述方法获取的数据均是以列为单位的。下面是以行为单位获取数据的方法：
df4[:3]
df4[3:6]
DataFrame还有loc/iloc、ix、at/iat访问方式。loc的参数为行索引名或者行索引名构成的列表，iloc为行索引号。loc/iloc的返回值可能是Series，有可能是DataFrame。
df4.loc['index1']
df4.loc['index1':'index3']
df4.loc[['index1':'index3']]
df4.loc['index2':]
df4.iloc[0]
df4.iloc[0:3]
df4.iloc[:3]
ix可返回DataFrame、Series以及具体的元素值：
df4.ix['index1']
df4.ix['index1':'index3']
df4.ix[['index1','index3']]
df4.ix[1]
df4.ix[1,0]
at也可返回具体的元素值：
df4.iat[0,1]
df4.at['index1','a']
df4['a']['index1']
df4.a['index1']
DataFrame索引和选择操作方法列表：

4. DataFrame的数据赋值：

可以在创建DataFrame时直接赋值，也可以后赋值。赋值列表数据时，需与源DataFrame的维数相同；赋值Series时无此要求。
df4['AA']=list((1,2,3,4,5))
df4['BB']=np.ones((5,2)).tolist()
df4['CC']=pd.Series((1,5,0,8,6),index=('index1','index2','index3','index4','index5'))

5. pandas的基本运算函数：

pandas的基础是NumPy，也有各种运算能力，包括矩阵运算。
df0.sum()
上述计算是以列为基础的。DataFrame提供了axis属性，取值为0或1，分别对应列和行。
df0.sum(axis=1) # 返回行内数据的和
数据中存在NaN时，默认情况下跳过，可通过skipna参数处理存在NaN值的情况：
df0.sum(skipna=False) # 含NaN的和为NaN
describe()函数可以一次性产生多个汇总统计：
df0.describe()
1）pandas数据结构的常用操作和属性：
import numpy as np
from pandas import *
randn=np.random.randn
index=date_range('1/1/2010',periods=10)
s=Series(randn(10),index=['I','II','III','IV','V','VI','VII','VIII','IX','X'])
df=DataFrame(randn(10,4),index=['I','II','III','IV','V','VI','VII','VIII','IX','X'], columns=['A','B','C','D'])
series_with100elements=Series(randn(100))
print(series_with100elements.head())
print(series_with100elements.tail(3))
print(series_with100elements[:3])
print(df[:2])
df.columns=[x.lower() for x in df.columns]
print(df)
print(s.values)
print(df.values)
2）统计函数describe、最大/最小索引idxmin/idxmax、按行/列标签或数值排序、对象功能转换、数值类型属性等：
import numpy as np
from pandas import *
randn=np.random.randn
# 统计函数describe
series=Series(randn(440))
series[20:440]=np.nan
series[10:20]=5
print(series.nunique())
series=Series(randn(1700))
series[::3]=np.nan
print(series.describe())
frame=DataFrame(randn(1200,5),columns=['a','e','i','o','u'])
frame.ix[::3]=np.nan
print(frame.describe())
print(series.describe(percentiles=[.05,.25,.75,.95]))
s=Series(['x','x','y','y','x','x',np.nan,'u','v','x'])
print(s.describe())
frame=DataFrame({'x':['Y','Yes','Yes','N','No','No'],'y':range(6)})
print(frame.describe())
print(frame.describe(include=['object']))
print(frame.describe(include=['number']))
print(frame.describe(include='all'))
# 最大索引与最小索引值
s1=Series(randn(10))
print(s1)
print(s1.idxmin())
print(s1.idxmax())
df1=DataFrame(randn(5,3),columns=['X','Y','Z'])
print(df1)
print(df1.idxmin(axis=0))
print(df1.idxmax(axis=1))
df3=DataFrame([1,2,2,3,np.nan],columns=['X'],index=list('aeiou'))
print(df3)
print(df3['X'].idxmin())
# 按标签排序和按数值排序
unsorted_df=df1.reindex(index=['a','e','i','o'],columns=['X','Y','X'])
unsorted_df.sort_index()
unsorted_df.sort_index(ascending=False)
unsorted_df.sort_index(axis=1)
df1=DataFrame({'X':[5,3,4,4],'Y':[5,7,6,8],'Z':[9,8,7,6]})
df1.sort_values(by='Y')
df1[['X','Y','Z']].sort_values(by=['X','Y'])
s=Series(['X','Y','Z','XxYy','Yxzx',np.nan,'ZXYX','Zoo','Yet'])
s[3]=np.nan
s.sort_values()
s.sort_values(na_position='first')
# 将目标值插入既定顺序，查找包含区间值的索引
ser=Series([4,6,7,9])
ser.searchsorted([0,5])
ser.searchsorted([1,8])
ser.searchsorted([5,10],side='right')
ser.searchsorted([5,10],side='left')
s=Series(np.random.permutation(17))
print(s)
print(s.sort_values())
print(s.nsmallest(5))
print(s.nlargest(5))
# 对多维索引进行排序
df1.columns=MultiIndex.from_tuples([('x','X'),('y','Y'),('z','Z')])
df1.sort_values(by=('x','X'))
# 查看DataFrame和Series的数据类型
dft=DataFrame(dict(I=np.random.rand(5),II=8,III='Dummy',IV=Timestamp('19751008'),
            V=Series([1.6]*5).astype('float32'),VI=True,VII=Series([2]*5,dtype='int8'),
            VIII=False))
print(dft)
print(dft.dtypes)
print(dft['III'].dtype)
print(dft['II'].dtype)
# 统计每种数据类型出现的次数
dft.get_dtype_counts()
df1=DataFrame(randn(10,2),columns=['X','Y'],dtype='float32')
print(df1)
print(df1.dtypes)
df2=DataFrame(dict(X=Series(randn(10)),Y=Series(randn(10),dtype='uint8'),
                   Z=Series(np.array(randn(10),dtype='float16'))))
print(df2)
print(df2.dtypes)
每种数据类型都是同样形式，实现迭代操作比较简单：
import numpy as np
from pandas import *
randn=np.random.randn
df=DataFrame({'one-1':Series(randn(3),index=['a','b','c']),
              'two-2':Series(randn(4),index=['a','b','c','d']),
              'three-2':Series(randn(3),index=['b','c','d'])})
for columns in df:
    print(columns)
df2=DataFrame({'x':[1,2,3,4,5],'y':[6,7,8,9,10]})
print(df2)
print(df2.T)
for r_index,rows in df2.iterrows():
    print('%s\n%s' % (r_index,rows))
df2_t=DataFrame(dict((index,vals) for index,vals in df2.iterrows()))
print(df2_t)
df_iter=DataFrame([[1,2.0,5]],columns=['x','y','z'])
row=next(df_iter.iterrows())[1]
print(row['x'].dtype)
print(df_iter['x'].dtype)
for row in df2.itertuples():
    print(row)
# 用dt存取器处理时间
s=Series(date_range('20150509 01:02:03',periods=5))
print(s)
print(s.dt.hour)
print(s.dt.second)
print(s.dt.day)
print(s[s.dt.day==2])
# 时区转换
stimezone=s.dt.tz_localize('US/Eastern')
print(stimezone)
print(stimezone.dt.tz)
s.dt.tz_localize('UTC').dt.tz_convert('US/Eastern')
# 周期
s=Series(period_range('20150509',periods=5,freq='D'))
print(s)
print(s.dt.year)
print(s.dt.day)
# 时间间隔
s=Series(timedelta_range('1 day 00:00:05',periods=4,freq='s'))
print(s)
print(s.dt.seconds)
print(s.dt.components)
3）pandas提供了大量的方法来实现描述性统计量的计算，还有计数、求和最小值、最大值、均值、中位数、标准方差、偏度、峰度、分位数、累计求和等函数。
import numpy as np
from pandas import *
randn=np.random.randn
df=DataFrame({'one-1':Series(randn(3),index=['a','b','c']),
              'two-2':Series(randn(4),index=['a','b','c','d']),
              'three-2':Series(randn(3),index=['b','c','d'])})
print(df)
print(df.mean(0))
print(df.mean(1))
print(df.mean(0,skipna=False))
print(df.mean(axis=1,skipna=True))
print(df.sum(0))
print(df.sum(axis=1))
print(df.sum(0,skipna=False))
print(df.sum(axis=1,skipna=True))
# NumPy的mean不统计缺失值
np.mean(df['one-1'])
np.mean(df['one-1'].values)
ser=Series(randn(10))
ser.pct_change(periods=3)
# 指定周期
df=DataFrame(randn(8,4))
df.pct_change(periods=2)
ser1=Series(randn(530))
ser2=Series(randn(530))
ser1.cov(ser2)
frame=DataFrame(randn(530,5),columns=['i','ii','iii','iv','v'])
frame.cov()
frame=DataFrame(randn(26,3),columns=['x','y','z'])
frame.ix[:8,'i']=np.nan
frame.ix[8:12,'ii']=np.nan
frame.cov()
frame.cov(min_periods=10)
frame=DataFrame(randn(530,5),columns=['i','ii','iii','iv','v'])
frame.ix[::4]=np.nan
# 用Pearson方法计算标准相关系数
frame['i'].corr(frame['ii'])
# 也可以指定用Kendall方法和Spearman方法
frame['i'].corr(frame['ii'],method='kendall')
frame['i'].corr(frame['ii'],method='spearman')
index=['i','ii','iii','iv']
columns=['first','second','third']
df1=DataFrame(randn(4,3),index=index,columns=columns)
df2=DataFrame(randn(3,3),index=index[:3],columns=columns)
df1.corrwith(df2)
df2.corrwith(df1,1)
s=Series(np.random.randn(10),index=list('abcdefghij'))
s['d']=s['b']
print(s.rank())
df=DataFrame(np.random.randn(8,5))
df[4]=df[2][:5]
print(df)
print(df.rank(1))

6. 时间序列与日期函数：

pandas提供了丰富的时间序列与日期操作函数，可以实现时间和日期的相关计算。pandas通过TimeStamp数据类型，可以获得大量的时间和日期属性，部分属性为：

import numpy as np
from pandas import *
randn=np.random.randn
# 创建日期区间
range_date=date_range('6/3/2015',periods=152,freq='H')
range_date[:5]
# 时间为索引
ts=Series(randn(len(range_date)),index=range_date)
print(ts.head())
# 把索引值的频率更新为40分钟
converted=ts.asfreq('40Min',method='pad')
converted.head()
ts.resample('D').mean()
dates=[datetime(2015,6,10),datetime(2015,6,11),datetime(2015,6,12)]
ts=Series(np.random.randn(3),dates)
type(ts.index)
print(ts)
# 创建周期索引
periods=PeriodIndex([Period('2015-10'),Period('2015-11'),Period('2015-12')])
ts=Series(np.random.randn(3),periods)
type(ts.index)
print(ts)
# 转换时间戳
to_datetime(['1995/10/31','2015.11.30'])
# 日期数值如果按照月-日-年的形式，就用dayfirst=True
to_datetime(['01-01-2015 11:30'],dayfirst=True)
to_datetime(['14-03-2007','03-14-2007'],dayfirst=True)
# 纪年时间戳默认使用纳秒，可以转换为秒和微秒
to_datetime([1449720105,1449806505,1449892905,1449979305,1450065705],unit='s')
to_datetime([1349720105100,1349720105200,1349720105300,1349720105400,1349720105500],unit='ms')
to_datetime([8])
to_datetime([8,4.41],unit='s')
# 取一定范围的日期
dates=[datetime(2015,4,10),datetime(2015,4,11),datetime(2015,4,12)]
index=DatetimeIndex(dates)
index=Index(dates)
index=date_range('2010-1-1',periods=1700,freq='M')
print(index)
index=bdate_range('2014-10-1',periods=250)
print(index)
start=datetime(2005,1,1)
end=datetime(2015,1,1)
range1=date_range(start,end)
print(range1)
range2=bdate_range(start,end)
print(range2)
日期信息也可以作为pandas数据结构的索引使用：
import numpy as np
from pandas import *
from pandas.tseries.offsets import *
randn=np.random.randn
start=datetime(2005,1,1)
end=datetime(2015,1,1)
rng=date_range(start,end,freq='BM')
ts=Series(randn(len(rng)),index=rng)
ts.index
ts[:8].index
ts[::1].index
# 可以直接用日期和字符串作为索引
ts['8/31/2012']
ts[datetime(2012,7,11):]
ts['10/08/2005':'12/31/2014']
ts['2012']
ts['2012-7']
dft=DataFrame(randn(50000,1),columns=['X'],index=date_range('20050101',periods=50000,freq='T'))
print(dft)
dft['2005']
# 从第一个参数里月份的最早时间到最后一个参数里月份的最晚时间
dft['2005-1':'2013-4']
dft['2005-1':'2005-3-31']
# 可以指定停止时间
dft['2005-1':'2005-3-31 00:00:00']
dft['2005-1-27':'2005-1-17 05:30:00']
# 日期索引
dft[datetime(2005,1,1):datetime(2005,3,31)]
dft[datetime(2005,1,1,1,2,0):datetime(2005,3,31,1,2,0)]
# 用loc选择一行数据
dft.loc['2005-1-17 05:30:00']
# 截取一段时间
ts.truncate(before='1/1/2010',after='12/31/2012')

7. 处理缺失数据：

缺失数据是指数据为空null或没显示，通常用Na*表示缺失数据，如NaN表示缺失数值，NaT表示缺失时间值。pandas检查缺失数据的函数为isnull和notnull，函数fillna、dropna、rloc、iloc、interpolate填补缺失数据。如果对NaN对象执行任何操作，结果仍为NaN。
import numpy as np
from pandas import *
randn=np.random.randn
df=DataFrame(randn(8,4),index=['I','II','III','IV','VI','VII','VIII','X'],
             columns=['A','B','C','D'])
df['E']='Dummy'
df['F']=df['A']>0.5
print(df)
# 通过增加索引来引入缺失值
df2=df.reindex(['I','II','III','IV','V','VI','VII','VIII','IX','X'])
print(df2)
df2['A']
# 检查是否存在缺失值
isnull(df2['A'])
df2['D'].notnull()
df3=df.copy()
df3['timestamp']=Timestamp('20120711')
print(df3)
# 把timestamp列缺失值设置为NaT
df3.ix[['I','III','VIII'],['A','timestamp']]=np.nan
print(df3)
s=Series([5,6,7,8,9])
s.loc[0]=None
print(s)
s=Series(['A','B','C','D','E'])
s.loc[0]=None
s.loc[1]=np.nan
print(s)
# 用fillna方法填充缺失值
print(df2)
df2.fillna(0)                   # 填充索引缺失值为0
df2['D'].fillna('missing')      # 为某一列填充缺失值
df2.fillna(method='pad')
print(df2)
df2.fillna(method='pad',limit=1)
df2.dropna(axis=0)
df2.dropna(axis=1)
ts=Series(randn(30))
ts.count()
ts[10:30]=None
ts.count()
# 利用插值方法填充缺失值，默认使用线性插值
ts.interpolate()
ts.interpolate().count()

8. pandas的IO操作：

pandas的IO API为pandas提供数据源，目前支持下列文件读写，CSV、Excel、JSON、HTM、剪切板、PyTables/HDF5、Stata、pickle。提供了read_csv、read_excel、read_hdf、read_sql、read_json、read_html、read_stata、read_clipboard、read_pickle等加载函数以及to_csv、to_excel、to_hdf、to_sql、to_json、to_html、to_stata、to_clipboard、to_pickle等转换函数。
1）处理CSV文件：
import numpy as np
from pandas import *
randn=np.random.randn
user_columns=['User-ID','Location','Age']
users=read_csv('c:\BX-Users.csv',sep=';',names=user_columns)
rating_columns=['User-ID','ISBN','Rating']
users=read_csv('c:\BX-Book-Rating.csv',sep=';',names=rating_columns)
book_columns=['ISBN','Book-Title','Book-Author','Year-Of-Publication',
              'Publisher','Image-URL-S']
books=read_csv('c:\BX-Books.csv',sep=';',names=rating_columns,usecols=range(6))
print(books)
print(books.dtypes)
user.describe()
print(books.head())
print(books.tail(8))
print(books[5:10])
users['Location'].head()
print(users[['Age','Lacation']].head())
desired_columns=['User-ID','Age']
print(users[desired_columns].head())
print(users[users.Age>25].head(4))
print(users[(users.Age<50)&(users.Location=='chicago,illinois,usa')].head(4))
print(users.set_index('User-ID').head())
print(users.head())
with_new_index=users.set_index('User-ID')
print(with_new_index.head())
users.set_index('User-ID',inplace=True)
print(users.head())
print(users.ix[62])
print(users.ix[[1,100,200]])
users.reset_indexd(inplace=True)
print(users.head())
在数据集上的merge、groupby和相关操作，如排序、分类、寻找最大的n个数以及数据：
import numpy as np
from pandas import *
randn=np.random.randn
user_columns=['User-ID','Location','Age']
users=read_csv('c:\BX-Users.csv',sep=';',names=user_columns)
rating_columns=['User-ID','ISBN','Rating']
ratings=read_csv('c:\BX-Book-Rating.csv',sep=';',names=rating_columns)
book_columns=['ISBN','Book-Title','Book-Author','Year-Of-Publication',
              'Publisher','Image-URL-S']
books=read_csv('c:\BX-Books.csv',sep=';',names=rating_columns,usecols=range(6))
book_rating=merge(books,ratings)
users_ratings=merge(book_ratings,users)
most_rated=users_ratings.groipby('Title').size().order(ascending=False)[:25]
print(most_rated)
users_ratings.Title.value_counts()[:17]
book_stats=users_ratings.groupby('Title').agg({'Rating':[np.size,np.mean]})
print(book_stats.head())
# 按照评分等级Rating与均值mean排序
print(book_stats.sort([('Rating','mean')],ascending=False).head())
greater_than_100=book_stats['Rating'].size>=100
print(book_atats[greater_than_100].sort([('Rating','mean')],ascending=False)[:15])
top_fifty=users_ratings.groupby('ISBN').size().order(ascending=False)[:50]
下面程序演示了DataFrame的合并与连接操作：
import numpy as np
from pandas import *
randn=np.random.randn
first_frame=DataFrame({'key':range(10),'left_value':['A','B','C','D','E','F','G','H','I','J']})
second_frame=DataFrame({'key':range(2,12),'right_value':['L','M','N','O','P','Q','R','S','T','U']})
print(first_frame)
print(second_frame)
# 默认合并join操作inner join
print(merge(left_frame,right_frame,on='key',how='inner'))
# 其他合并操作left、right、outer
print(merge(left_frame,right_frame,on='key',how='left'))
print(merge(left_frame,right_frame,on='key',how='right'))
print(merge(left_frame,right_frame,on='key',how='outer'))
concat([left_frame,right_frame])
concat([left_frame,right_frame],axis=1)
headers=['name','title','departmen','salary']
chicago_details=read_csv('c:\city-of-chicago-salaries.csv',header=False,
        names=headers,converters={'salary':lambda x:float(x.replace('$',''))})
print(chicago_detail.head())
dept_group=chicago_details.groupby('department')
print(dept_group)
print(dept_group.count().head(10))
print(dept_group.size().tail(10))
print(dept_group.sum()[10:17])
print(dept_group.mean()[10:17])
print(dept_group.median()[10:17])
chicago_details.sort('salary',ascending=False,inplace=True)
2）使用StringIO：
import StringIO
myIO=StringIO.StringIO()
myIO=df0.to_json()
jsondata=pd.read_json(myIO)
df0.to_excel('c:\\exceldata.xml')
exceldata=pd.read_excel('c:\\exceldata.xml')

9. 直接读取网络数据：

pandas还提供了直接读取网络数据的方式，可以读取一些网站提供的数据源。支持雅虎财经、谷歌财经、美联储经济数据，Kenneth French数字图书馆、世界银行等，也有一些Python财经数据接口包，比如tushare。
import pandas.io.data  as web
import datetime
f1=web.DataReader('F','yahoo',datetime.datetime(2010,1,1),datetime.datetime(2011,12,31))
f2=web.DataReader('F','google',datetime.datetime(2010,1,1),datetime.datetime(2011,12,31))
f3=web.DataReader('GDP','fred',datetime.datetime(2010,1,1),datetime.datetime(2011,12,31))
f1.ix['2010-05-12']

10. pandas画图：

pandas通过封装Matplotlib的plot支持画图功能，默认情况下画的都是线图，可以通过修改画图函数的kind属性改变图形样式。df.plot()不同图形的样式参数有：
·条形图df.plot(kind='bar')
·直方图df.plot(kind='hist')
·箱体图df.plot(kind='box')
·面积图df.plot(kind='area')
·散点图df.plot(kind='scatter')
·饼图df.plot(kind='pie')
from pandas import *
import numpy as np
import matplotlib.pyplot as plt
randn=np.random.randn
x1=np.array(((1,2,3),(1,4,6),(2,4,8)))
df=DataFrame(x1,index=['I','II','III'],columns=['A','B','C'])
df=df.cumsum()
df.plot(kind='pie',subplots=True)
plt.show()