利用python进行数据分析-学习笔记_python中count().unstack().fillna(0)

-------------------------------------------------CP names_case------------------------------------------------
-------------------------------------------------------names-------------------------------------------------------
#coding=gbk
import pandas as pd
import numpy as np
from pandas import Series ,DataFrame
import matplotlib.pyplot as pl
from datetime import datetime
from pandas .tseries.offsets import Hour,Minute,Day,MonthEnd
from dateutil.parser import parse
names1880=pd.read_csv('E:/work/qbao/PY-W/pydata-book-master/ch02/names/yob1880.txt',names=['name','sex','births'])
names1880
names1880.groupby('sex').births.sum()
#读取,合并多个文件
years=range(1880,2011)
pieces=[]
columns=['name','sex','births']
for year in years:
	path='E:/work/qbao/PY-W/pydata-book-master/ch02/names/yob%d.txt' %year
	frame=pd.read_csv(path,names=columns)
	frame['year']=year
	pieces.append(frame)
names=pd.concat(pieces,ignore_index=True)
#男女出身人口数TS序列曲线
total_births=names.pivot_table('births',index='year',columns='sex',aggfunc=sum)
total_births.plot(title='birth of sex')
#插入一个prop列 统计百分比
def add_prop(group):
	births=group.births.astype(float)
	group['prop']=births/births.sum()
	return group
names=names.groupby(['year','sex']).apply(add_prop)
#计算比例总和是否为1
np.allclose(names.groupby(['year','sex']).prop.sum(),1)
#取出排名前1000
def get_top1000(group):return group.sort_index(by='births',ascending=False)[:1000]
grouped=names.groupby(['year','sex'])
top1000=grouped.apply(get_top1000)
##
pieces=[]
for year,group in names.groupby(['year','sex']):pieces.append(group.sort_index(by='births',ascending=False)[:1000])
top1000=pd.concat(pieces,ignore_index=True)
 
#分析命名趋势
boys=top1000[top1000.sex=='M']
girls=top1000[top1000.sex=='F']
total_births=top1000.pivot_table('births',index='year',columns='name',aggfunc=sum)
#4个姓名的取名趋势subplot图
subset=total_births[['John','Harry','Mary','Marilyn']]
subset.plot(subplots=True,figsize=(12,10),grid=False,title='number of births per year')
#评估命名多样性增长
table=top1000.pivot_table('prop',index='year',columns='sex',aggfunc=sum)
table.plot(title='sum of table1000.prop by year and sex',yticks=np.linspace(0,1.2,13),xticks=range(1880,2020,10))
df=boys[boys.year==2010]
#计算组成50%的人数
prop_cumsum=df.sort_index(by='prop',ascending=False).prop.cumsum()
prop_cumsum.searchsorted(0.5)
df=boys[boys.year==1900]
in1900=df.sort_index(by='prop',ascending=False).prop.cumsum()
in1900.searchsorted(0.5)+1
def get_quantile_count(group,q=0.5):
	group=group.sort_index(by='prop',ascending=False)
	return group.prop.cumsum().searchsorted(q)+1
diversity=top1000.groupby(['year','sex']).apply(get_quantile_count)
diversity=diversity.unstack('sex')
diversity.plot(title='Number of popular names in top 50%')#年度统计密度表
 
#最后一个字母的分析
get_last_letter=lambda x:x[-1]
last_letters=names.name.map(get_last_letter)
last_letters.name='last_letter'
table=names.pivot_table('births',index=last_letters,columns=['sex','year'],aggfunc=sum)
subtable=table.reindex(columns=[1910,1960,2010],level='year')
subtable.head()
subtable.sum()
letter_prop=subtable/subtable.sum().astype(float)
 
fig,axes=pl.subplots(2,1,figsize=(10,8))
letter_prop['M'].plot(kind='bar',rot=0,ax=axes[0],title='Male')
letter_prop['F'].plot(kind='bar',rot=0,ax=axes[1],title='Female',legend=False)
letter_prop=table/table.sum().astype(float)
dny_ts=letter_prop.ix[['d','n','y'],'M'].T
dny_ts.head()
dny_ts.plot()
 
all_names=top1000.name.unique()
mask=np.array(['lesl' in x.lower() for x in all_names])
lesley_like=all_names[mask]
lesley_like
 
filtered=top1000[top1000.name.isin(lesley_like)]
filtered.groupby('name').births.sum()
 
table=filtered.pivot_table('births',index='year',column='sex',aggfunc='sum')
table=table.div(table.sum(1),axis=0)
table.tail()
table.plot(style={'M':'k-','F':'k--'})
-------------------------------------------------------movielens-------------------------------------------------------
#coding=gbk
import pandas as pd
import numpy as np
from pandas import Series ,DataFrame
import matplotlib.pyplot as pl
from datetime import datetime
from pandas .tseries.offsets import Hour,Minute,Day,MonthEnd
from dateutil.parser import parse
data=pd.read_table('C:/Users/admin/Desktop/PY-W/timeseries/get.csv')
unames=['user_id','gender','age','occupation','zip']
users=pd.read_table('E:/work/qbao/PY-W/pydata-book-master/ch02/movielens/users.dat',sep='::',header=None,names=unames)
rnames=['user_id','movie_id','rating','timestamp']
ratings=pd.read_table('E:/work/qbao/PY-W/pydata-book-master/ch02/movielens/ratings.dat',sep='::',header=None,names=rnames)
mnames=['movie_id','title','genres']
movies=pd.read_table('E:/work/qbao/PY-W/pydata-book-master/ch02/movielens/movies.dat',sep='::',header=None,names=mnames)
da=pd.merge(pd.merge(ratings,users),movies)
#calculate avg(score)---pivot
mean_ratings=data.pviot_table('rating',index='title',columns='gender',aggfunc='mean')
#calculate count(*)---group by title 
rating_by_title=da.groupby('title').size()
#filtering >250
active_title=rating_by_title.index[rating_by_title>250]
active_title[:10]
#top female like
top_f_like=mean_ratings.sort_index(by='F',ascending=False)
#rating[diff]
mean_ratings['diff']=mean_ratings['M']-mean_ratings['F']
sorted_by_diff=mean_ratings.sort_index(by=='diff')
#std
rating_std_by_title=da.groupby('title')['rsting'].std()
#
rating_std_by_title=rating_std_by_title.ix[active_title]
rating_std_by_title.order(ascending=False)[:10]
 
'''df2=pd.read_csv('C:/Users/admin/Desktop/pyda/tes.csv')
mpl.rcParams['font.sans-serif'] = ['SimHei']'''
 
 
-------------------------------------------------------USA.gov-------------------------------------------------------
#encodig=gbk
path='E:/work/qbao/PY-W/pydata-book-master/ch02/usagov_bitly_data2012-03-16.txt'
#open(path).readline()
import json
record=[json.loads(line) for line in open(path)]
record[0]['tz'] #第一条记录中的tz字段value
time_zones=[rec['tz'] for rec in record if 'tz' in rec] #count(tz) if tz notnull
 
--------------------------Method of PANDAS ------------------------------
#use the value_counts() to count
from pandas import DataFrame,Series
import pandas as pd ; import numpy as np
frame =DataFrame(record)
frame['tz'][:10]
tz_count=frame['tz'].value_counts()
tz_count[:10]
#frame['c'][:10].value_counts().plot(kind='bar')
clean_tz=frame['tz'].fillna('Missing')
clean_tz[clean_tz==' ']='Unknown'
tz_counts=clean_tz.value_counts()
tz_counts[:10].plot(kind='barh',rot=0)
#对字段a进行描述count
result=Series([x.split()[0] for x in frame.a.dropna()])
result.value_counts()[:10].plot(kind='barh')
cframe=frame[frame.a.notnull()] # frame(remove value='null' among a)
operating_sys=np.where(cframe['a'].str.contains('Windows'),'windows','not windows')
by_tz_os=cframe.groupby(['tz',operating_sys])
agg_count=by_tz_os.size().unstack().fillna(0)
agg_count[:10]
#升序排列
indexer=agg_count.sum(1).argsort()
indexer[:10]
#截取后十行
count_subset=agg_count.take(indexer)[-10:]
count_subset
count_subset.plot(kind='barh',stacked=True)
#截取后十行的百分比例图
normed_subset=count_subset.div(count_subset.sum(1),axis=0)
normed_subset.plot(kind='barh',stacked=True)
 
---------------Method of standard-way---------------------
#create count()-formula
def get_count(sequence): 
	count={}
	for x in sequence:
		if x in count:
			count[x]+=1
		else:
			count[x]=1
	return count
#w2
from collections import defaultdict
def get_count2(sequence):
	count=defaultdict(int)
	for x in sequence:
		count[x]+=1
	return count
#counting
count=get_count2(time_zones)
count['America/New_York']
#前十位城市计数函数
def top_count(count_dict,n=10):
	value_key_pairs=[(count,tz) for tz,count in count_dict.items()]
	value_key_pairs.sort()
	return value_key_pairs[-n:]
top_count(count)
##method of collections.Counter
from collections import Counter
counts=Counter(time_zones)
counts.most_common(10)
 
 
 
-------------------------------------------------CP4 numpy------------------------------------------------
#coding=gbk
import pandas as pd
import numpy as np
from pandas import Series ,DataFrame
import matplotlib.pyplot as pl
from datetime import datetime
from pandas .tseries.offsets import Hour,Minute,Day,MonthEnd
from dateutil.parser import parse
from numpy.linalg import inv,qr
 
---------basic---------
d=[[1,2,3],[4,5,6]]
arr1=np.array(d)
arr1.shape ------> (2,3)
arr1.dtype ------> int32
np.zeros(10)
np.zeros((3,6)) ------>3list（6元素） 
np.empty((2,3,2)) ----->2list 3子list（2元素）
np.arange(15) ------> 0 to 14 的ndarry
'''np函数
ones/ones_like,   --->1数组
zeros/zeros_like, --->0数组
empty/empty_like  --->new array,只分配内存空间 不填充值
eye/identity      --->N*N矩阵 对角线为1 else0
'''
arr2=np.array([1,2,3],dtype=np.float64/int32)
arr2.astype(np.float64)  #转换数据类型
#数组标量运算
arr3=np.array([[1,2,3],[4,5,6]])
arr3*arr3,arr3-arr3,1/arr3,arr3**0.5
-------数组ix和slice
arr4=np.arange(10)   ------->arr4[:5]/arr4[:5]=1  #单维数组
arr5=np.array([[[1,2,3],[5,6,7]],[[7,8,9],[10,11,12]]]) ------->arr5[1][0][1] = 8  == arr5[1][0][1]
arr5[1,:,:1]  --------->第2个 所有子 第一个数字 7&10
arr5[:,:,1:]  --------->取出第2,3列
#运用bool数组
names=np.array(['zieox','kol','sisi','jack','lucy','mark','olk'])
dat=randn(7,3)       --------->随机取7组3元素
dat[names=='zieox']  --------->利用bool数组取出randn值
dat[dat<0]=1/dat[names!='zieox']=1
-------花式数组
arr=np.empty((8,4))
for i in range(8):
	arr[i]=i
arr[[2,3,5]]
arr7=np.arange(32).reshape((8,4))/arr7=np.random.randn(32).reshape((8,4)) #reshape
arr7[[1,5,7,2],[0,3,1,2]]    -------->取10 53 71 22
arr7[[1,5,7,2]][:,[0,3,1,2]] -------->取1572list 中的0312
或者 arr7[np.ix_([1,5,7,2],[0,3,1,2])]
------数组转置与轴对换
arr8=np.arange(15).reshape((3,5))  ----->arr8.T
------计算矩阵内积
arr=np.random.randn(6,3)
np.dot(arr.T,arr)
------高纬数组轴转置
arr9=np.arange(16).reshape((2,2,4))
arr9.swapaxes(1,2)
------------------通用函数
abs/fabs                             绝对值
sqrt                                 平方根
square                               平方
exp                                  指数e^x
log/log10/log2/log1p                 log
sign                                 元素正负号,1正 0 -1负
ceil                                 向上圆整
floor                                向下圆整
rint                                 四舍五入
modf                                 拆开整数和小数,返回数组
isnan                                是否是NAN的bool
isfinite/isinf                       返回哪些元素是有穷/无穷的bool数组
cos/cosh/sin/sinh/tan/tanh           普通/双曲型三角函数
arccos/arccosh/arcsin/arcsinh/arctan/arctanh          反三角函数
logical_not                          计算元素notX 的真值
 
-------二元
add                                  将数组中对应元素相加                        
subtract                             第一个数组元素减去第二个
multiply                             数组元素相乘
divide/floor_divide                  触发或向下元整除法
power                                数组A 根据数组B计算 A^B
maximum/fmax                         元素级最大值
minimum/fmin                         元素级最小值 
mod                                  元素级求模计算
copysign                             将第二个数组中值得符号赋予第一个数组
greater/greater_equal/               执行元素级比较最终产生bool数组
less/less_equal/equal/not_equal      >,>=,<,<=,==,!=
logical_and/logical_or/logical_xor   执行元素级真值逻辑运算（&,|,^）
 
-----------利用数组进行数据处理
points=np.arange(-5,5,0.01)
xs,ys=np.meshgrid(points,points) #2个一维数组合并成一个2维数组
z=np.sqrt(xs**2+ys**2)           #(x方+y方)^0.5
pl.imshow(z,cmap=pl.cm.gray);pl.colorbar()
pl.title('Image plot of $\sqrt{x^2+y^2}$ for a grid of values')
 
----------将条件逻辑表达式表述为数组运算
xarr=np.array([1.1,1.2,1.3,1.4,1.5])
yarr=np.array([2.1,2.2,2.3,2.4,2.5])
conda=np.array([True,False,True,True,False])
arr=randn(4,4)  #where 
np.where(arr>0,1,-1)
np.where(arr>0,2,arr)
#array多条件判断 赋值
result=[]
for i in range(n):
	if cond1[i] and cond2[i]:
		result.append[0]
	elseif cond1[i]:
		result.append[1]
	elseif cond2[i]:
		result.append[2]
	else:
		result.append[3]
np.where(cond1&cond2,0,np.where(cond1,1,np.where(cond2,2,3)))
result=1*(cond1-cond2)+2*(cond2&-cond1)-(cond1|cond2)
 
----------数学和统计方法
arr=np.random.randn(5,4)
for i in range(0,4):
	print(arr[i].mean())
#
sum       求和             mean            平均值   
cumsum    累积和           cumpord         累计乘
std/var   标准差和方差      argmin/argmax   返回最大小值序号  
arr=np.random.randint(5,size=(2,3))
arr.cumsum(1)  #根据axis=1 按照->行 累和
arr.cumsum(0)  #根据axis=1 按照|列  累和
 
----------用于bool型数组方法
(arr>0).sum()   #返回的是值得个数
bools=np.array([False,False,True,False])
bools.any()   #用于检查是否含有True
bools.all()   #用于检查全是True  #用于非bools数组时 所有非0元素将被视为True
 
----------排序
arr1=np.random.randn(5.3)
arr.sort(1)  #1根据行,0根据列 #注意：这里会改变数组，产生非视图
lararr=np.random.randn(1000)
lararr.sort()
lararr[int(0.05*len(lararr))]
 
----------唯一化及其他结合逻辑
names=np.array(['zieox','jack','rose','hack','zeox','hack'])
np.unique(names)
np.in1d(names,['jack','jis','zieox']) 
#
unique(x)           唯一直 
union1d(x,y)        x,y的并集,返回有序结果       
setdiff1d(x,y)      集合差,在x不在y                          
intersect(x,y)      x,y中的共有元素 并返回序列
in1d(x,y)           x是否包含于y 
setxor1d(x,y)       集合对称差，存在一个数组 但不在2者
 
----------存取文本文件
arr=np.loadtxt('~.txt',delimeter=',')
 
----------线性代数
x=np.array([[1,2,3],[4,5,6]])
y=np.array([[6,23],[-1,7],[8,9]])
x.dot(y) / np.dot(x,y)   #矩阵乘法
X=np.random.randn(5,5)
mat=X.T.dot(X)
inv(mat)
mat.dot(inc(mat))
q,r=qr(mat)
 
#常用函数
diag                 以一维数组的形式返回方阵的对角线(或非对角线)元素，或·将一维数组转换为方阵（非对角线元素为0）
dot                  矩阵乘法
trace                计算对角线元素和
det            ····      计算矩阵行列式
eig                  计算方阵的本征值和本征向量
inv                  计算方阵的逆
pinv                 计算举证的Moore-Penrose伪逆
qr                   计算QR分解
svd                  计算奇异值分解（SVD）
solve                解线性方程组Ax=b ,(A是一个方阵)
istsq                计算Ax=b的最小二乘解
 
------------随机数生成
samples=np.random.normal(size=(4,4))
from random import normalvariate
N=100000
%timeit samples=[normalvariate(0,1) for _ in xrange(N)]
%timeit np.random.normal(size=N)
 
#numpy.random函数
seed               确定随机数生成器种子
permutation        返回一个序列的随机排列 或 返回一个随机排列的范围
shuffle            对一个序列就地随机排列
rand               产生均匀分布的样本值
randint            从给定的上下限范围内随机取整数
randn              产生mean=0 std=1的标准正态分布
binomial           产生二项分布样本值
normal             产生正态分布样本值
beta               产生beta分布样本值
chisquare          产生卡方分布样本值
gamma              产生样gamma本值
uniform            产生[0,1)中均匀分布的样本值
 
 
 
-------------------------------------------ex 随机漫步-------------------------------------------
import random 
#method1-标准库
position=0
walk=[position]
steps=1000
for i in xrange(steps):
	step=1 if random.randint(0,1) else -1
	position+=step
	walk.append(position)
#np.where方式
nsteps=1000
draws=np.random.randint(0,2,size=nsteps)
steps=np.where(draws>0,1,-1)
walk=steps.cumsum()
a=pd.Series(walk)
a.plot()
pl.show()
walk.min() / walk.max()
(np.abs(walk)>=10).argmax() #返回绝对值大于10的最大值序号
 
-------------------一次模拟多个随机漫步
创建多维数组（按维计做次）
nwalks=5000
nsteps=1000
draws=np.random.randint(0,2,size=(nwalks,nsteps))
steps=np.where(draws>0,1,-1)
walks=steps.cumsum(1)
walks.max() / walks.min()
hist30=(np.abs(walks)>=30).any(1)
hist30.sum()
crossing_time=(np.abs(walks[hist30])>=30).argmax(1)
 
 
steps=np.random.normal(loc=0,scale=0.25,size=(nwalks,nsteps))
 
 
---------------------------------------------numpy Senior------------------------------------------------
np.ones((10,5)).shape
np.ones((3,4,5),dtype=float).strides
 
------numpy数据类型体系
ints=np.ones(10,dtpye=np.unit16)
floats=np.ones(10,dtpye=np.float32)
np.issubtype(ints.dtype,np.integer)
 
------数组重塑
arr=np.arange(8) --->arr.reshape((4,2))-->arr.reshape((4,2)).reshape((2,4))
arr2=np.arange(15)--->arr.reshape((5,-1)) #均匀分配
ot_arr=np.ones((3,5))--->ot_arr.shape--->arr2.reshape(ot_arr.shape)
 
------reshape的反运算为raveling/flatten(返回副本)
arr2=np.arange(15).reshape((5,3)) --->arr2.ravel()
 
 
---------------数组的合并与拆分
#合并
arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.array([[7,8,9],[10,11,12]])
np.concatenate([arr1,arr2],axis=0)  4list<|>  np.vstack((arr1,arr2)) #arr1中加arr2
np.concatenate([arr1,arr2],axis=1)   2list<-> np.hstack((arr1,arr2)) #arr1中元素级+
#拆分
arr=np.random.randn(5,2)
first,second,third=np.split(arr,[1,3])
#数组连接函数 
concatenate                       一般化连接，沿一条轴连接一组数组
vstack,row_stack                  面向行方式 对数组进行重叠（ix=0）
hstack                            面向列方式 对数组进行重叠（ix=1）
columns_stack                     类似hstack，但是会先将一维数组转换为二位列向量
dstack                            面向‘深度’的方式 对数组进行堆叠（ix=2）
split                             沿指定轴在指定的位置拆分数组
hsplit,vsplit,dsplit              沿轴0,1,2进行拆分
 
#堆叠辅助：r_ 和 c_
arr3=np.arange(6)
arr4=arr3.reshape((3,2))
arr5=np.random.randn(3,2)
np.r_[arr4,arr5]               #合并进行（axis=0）
np.c_[np.r_[arr4,arr5],arr3]   #合并进列
 
---------------元素的重复操作：title和repeat
arr6=np.arange(3)
arr6.repeat(3)
arr6.repeat([2,3,4])  #内元素 *2*3*4
arr7=np.random.randn(2,2)
arr7.repeat([2,3],axis=0)    #在行上(|)对一个子*2,第二个*3
np.tile(arr7,(3,2))          #将arr7视为块,进行‘|’*3  ‘-’*2的铺设
 
 
---------------花式索引的等价函数：take和put（用来选取数子集）
arr8=np.arange(10)*100
inds=[7,1,2,6]
arr8[inds]
arr8.take(inds)   #选取数组子集
arr8.put(inds,42)
arr8.put(inds,[40,41,42,43])
inds=[2,0,2,1]
arr9=np.random.randn(2,4) #2行4元素
arr9.take(inds,axis=1)    #取出子元素中序为3132的 #相当按照arr9排列为行后 按列取值 +1是为了取全部子
arr9.take([0],axis=0)     #取出第一行    若[0,1,0] 则取出第1,2,1行 得出结果
arr9.take([0],axis=1)     #取出第一列    若[0,1,0] 则取出第1,2,1列 得出结果
 
---------------广播（broadcasting）
arr=np.random.randn(4,3)
arr.mean(0)           ‘3’    ------>0行 1列  (0:对各列的行求均值，例：子的第一位置by行求均)
demeaned=arr-arr.mean(0)     ------>离均差
row_means=arr.mean(1)
row_means.reshape((4,1))
demeaned2=arr-row_means.reshape((4,1))  #广播原则中 广播维必须是1
arr=np.zeros((4,4))
ar3d=arr[:,np.newaxis,:]
ar3d.shape                    ====>(4,1,4) 
ar1d=np.random.normal(size=3)
ar1d[:,np.newaxis]
ar1d[np.newaxis,:]
---平距化
arr3=np.random.randn(3,4,5)
deep_means=arr3.mean(2)
demeaned3=arr-deep_means[:,:,np.newaxis]
 
def demean_axis(arr,axis=0):
	means=arr.mean(axis)
	indexer=[slice(None)]*arr.ndim
	indexer[axis]=np.newaxis
	return arr - means[indexer]
---------通过广播设置数组的值
arr5=np.zeros((4,3))
arr5[:]=5
col=np.array([1.25,-0.42,0.44,1.6])
arr5[:]=col[:,np.newaxis]
arr5[:2]=[[-1.33],[0.555]]
 
---------ufunc实例
arr=np.arange(10)
np.add.reduce(arr)    #相当于1-9的和
arr.sum()
 
arr=np.random.randn(5,5)
arr[::2].sort(1)                     ----->隔行根据ix=1排序
arr[:,:-1]<arr[:,1:]
np.logical_and.reduce(arr[:,:-1]<arr[:,1:],axis=1)
arr=np.arange(15).reshape((3,5))
np.add.accumulate(arr,axis=1)        ------>按<->累加
 
---利用outer计算差积
arr=np.arange(3).repeat([1,2,3])
np.multiply.outer(arr,np.arange(5))  ------>输出数据为2个输入数据维度之和
result=np.subtract.outer(np.random.randn(3,4),np.random.randn(5))
result.shape                         ------>(3,4,5)
 
arr=np.arange(10)
np.add.reduceat(arr,[0,5,8])
arr=np.multiply.outer(np.arange(4),np.arange(5))
np.add.reduceat(arr,[0,2,4],axis=1)
#ufunc方法
reduce(x)              通过连续执行原始运算的方式对值进行结合
accumulate(x)          聚合值，保留所有局部聚合结果
reduceat(x,bins)       局部简约（类group by） 约简数据的各个切片以产生聚合型数组
outer(x,y)             对x和y中的每对元素引用原始运算，结果数组的形状为x.shape+y.shape
 
----自定义ufunc
def add_elements(x,y):
	return x+y
add_them=np.frompyfunc(add_elements,2,1)
add_them(np.arange(8),np.arange(8))
add_them=np.victorize(add_elements,dtypes=[np.float64])
add_them(np.arange(8),np.arrange(8)
 
-----结构化和记录式数组
dtype=[('x',np.float),('y',np.int32)]
sarr=np.array([(1.5,6),(np.pi,-2)],dtype=dtype)
-----嵌套dtype和多维字段
dtype=[('x',np.int64,3),('y',np.int32)]
arr=np.zeros(4,dtype=dtype)
dtype=[('x',[('a','f8'),('b','f4')]),('y',np.int32)
data=np.array([((1,2),5],((3,4,),6)],dtype=dtype)
data['x']['a']
 
-----跟多排序话题
arr.sort(0)                 ------<|>行
arr=np.random.randn(3,5)
arr[:,0].sort() 第一列
 
-----间接排序：argsort和lexsort
values=np.array(['2:first','2:second','1:first','1:second','1:third'])
key=np.array([2,2,1,1,1])
indexer=key.argsort(kind='mergesort')
values.take(indexer)
#
quicksort 
mergesort
heapsort
 
----------np.searchsorted:在有序数组中查找元素
arr=np.array([0,1,7,12,15])
arr.searchsorted(9)
arr=np.array([0,0,0,1,1,1,1])
arr.searchsorted([0,1])
arr.searchsorted([0,1],side='right')
 
data=np.floor(np.random.uniform(0,10000,size=50))
bins=np.array([0,100,1000,5000,10000])
labels=bins.searchsorted(data)
Series(data).groupby(labels).mean()
np.digitize(data,bins)
 
 
----------np的matrix类
x=np.array([[8.254566,3.55445,33166],[1.464,2.5446,3.24865],[9.464,5.646,8.466]])
y=x[:,:1]
np.dot(y.T,np.dot(x,y))
xm=np.matrix(x)    --------->矩阵化
ym=xm[:,0]
ym.T*xm*ym
xm.I*x             ---------->返回矩阵的逆
 
--------内存映像文件
mmap=np.memmap('mymmap',dtype='float64',mode='w+',shape=(10000,10000))
section=mmap[:5]
del mmap
 
-------------------------------------------------CP5 pandas------------------------------------------------
https://www.cnblogs.com/batteryhp/p/5006274.html
import pandas as pd
import numpy as np
from pandas import Series ,DataFrame
import matplotlib.pyplot as pl
from datetime import datetime
from pandas .tseries.offsets import Hour,Minute,Day,MonthEnd
from numpy import nan as NA
import pandas_datareader.data as web
--------------basic Series------------
obj=Series([4,7,-5,3])
obj.values
obj.index
 
obj2=Series([4,7,-5,3],index=['d','b','a','c'])
obj2[['d','a']]
obj2[obj2>0]
obj2*2
np.exp(obj2)
 
sdata={'ohio':35000,'texas':71000,'oregon':16000,'utah':5000}
obj3=Series(sdata)
states=['california','ohio','oregon','texas']
obj4=Series(sdata,index=states)
pd.isnull(obj4)/pd.notnull(obj4)
obj4.isnull()
obj4.name='population'
obj4.index.name='state'
obj.index=['bob','steve','jeff','ryan']
obj7=Series([6.5,7.8,-5.9,8.6],index=['d','b','a','c'])
obj8=obj3.reindex(['a', 'b', 'c', 'd'，'e'],fill_value=0)
----------------------DataFrame----------------------
 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(data, columns=['year', 'state', 'pop'])
------基本操作
frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
frame2['state']                 --->state 列
frame2.year                     --->year 列
frame2.ix['three']              --->index=‘three’
frame2['debt'] = 18.5           --->将debt设置为18.5
frame2['debt'] = np.arange(5.)  --->将debt设置为0-4
val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
frame2['debt']=val              --->frame2载入val
frame2['eastern'] = frame2.state == 'Ohio'  --->加入新列并赋值--frame2.state == 'Ohio' 返回true
del frame2['eastern']           --->删除eastern列
------嵌套字典
pop = {'Nevada': {2001: 2.4, 2002: 2.9},'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3=DataFrame(pop)
frame3.T      --->行列转置
DataFrame(pop, index=[2001, 2002, 2003])
pdata = {'Ohio': frame3['Ohio'][:-1],'Nevada': frame3['Nevada'][:2]}
DataFrame(pdata)
frame3.index.name = 'year'; frame3.columns.name = 'state'  --->设置行列名
 
---#5-1 DataFrame可接受的数据结构
二维ndarray                       数据矩阵，可传入行标和列标
数组，列表或元祖组成的字典           每个序列会变成dataframe的一列。所有序列长度必须相同
np的结构化数组/记录数组             类似于由数组组成的字典
由series组成的字典                 每个series成为一列，若没有显式指定索引，则各series的索引会被合并成结果的行索引
由字典组成的字典                   各内层字典成为一列，键会被合并成结果的行索引
字典或series的列表                 各项将会成为dataframe的一行，字典键或series索引的并集将成为dataframe的列标  
由列表或元祖组成的列表              类似ndarry 
另一个dataframe                   该dataframe的索引将会被沿用，除非显示指定其他索引
numpy或makedarray                 类似于‘二维ndarray’，只是掩码值在结果dataframe会变成NA缺失值
 
frame3.index.name = 'year'; frame3.columns.name = 'state'  --->设置行列名
frame3.values             --->values属性会以二维ndarray的形式返回DataFrame中的数据
frame2.values             --->只返回值
 
--------------索引对象-----------Index对象是不可修改的
obj = Series(range(3), index=['a', 'b', 'c'])
index=obj.index
index[1:]
 
---#5-2  pandas中主要index对象
Index                           最泛化index对象，将轴标签表示为一个由python对象组成的numpy数组
Int64index                      针对整数的特殊index
Multiindex                      ‘层次化’索引对象,表示单个轴上的多层索引.可看做由元祖组成的数组
Datetimeindex                   存储纳秒级时间戳(用numpy和datetime64类型表示)
Periodindex                     针对period数据(时间间隔)的特殊index
 
---#5-3  index的方法和属性
append                          连接另一个index对象，产生一个新的index
diff                            计算差集
intersection                    计算交集
union                           计算并集
isin                            计算一个指示各值是否都包含在参数集合中的布尔型数组
delete                          删除索引i处的元素,并得到新的index
drop                            删除传入的值,并得到新的index
insert                          将元素插入索引i处,并得到新的index
is_monotonic                    当各元素均大于等于前一个元素时,返回true
is_unique                       当index没用重复值时，返回true
unique                          计算index中唯一值得数组
---基本操作
obj = Series([1,2,3,4],index=['a','b','c','d'])
obj2=obj.reindex(['a','c','d','b','e'],fill_value = 0)
 
frame = DataFrame(np.arange(9).reshape((3,3)),index = ['a','c','d'],columns = ['Ohio','Texas','California'])
frame2 = frame.reindex(['a','b','c','d'])
或 frame2=pd.DataFrame(frame,index=['a','b','c','d'])
frame4 = frame.reindex(index = ['a','b','c','d'],columns=states,method = 'ffill')
 
frame.ix[['a','d','c','b'],states]  -------->使用ix的标签索引功能，重新索引变得比较简洁
 
---#reindex的(插值)method选项
ffill或pad                        前向填充值
bfill或backfill                   后向填充值
---#reindex函数的参数
index                             用作索引的新序列，既可以是index实例，也可以是其他序列型的python数据结构，index会被完全使用，就像没有任何复制一样
method                            插值(填充)方式
fill_value                        在重新索引的过程中,需要引入缺失值时使用的替代中值
limit                             前向或后向填充时的最大填充量
level                             在multiindex的指定级别上匹配简单索引,否则选取其子集
copy                              默认为true,无论如何都复制,如果为False 则新旧相等就不复制
 
---------------丢弃指定轴上的项
obj = Series(np.arange(3.),index = ['a','b','c'])
obj.drop('b')
frame.drop(['a'])               ------->丢弃a
frame.drop(['Ohio'],axis = 1)   ------->丢弃Ohio
 
---索引、选取和过滤
obj = Series([1,2,3,4],index=['a','b','c','d'])
frame = DataFrame(np.arange(9).reshape((3,3)),index = ['a','c','d'],columns = ['Ohio','Texas','California'])
obj['b':'c']
frame['Ohio']
frame[:2]
frame[frame['Ohio'] != 0]
#下面的方式是对frame所有元素都适用，不是行或者列,下面的得到的是numpy.ndarray类型的数据
frame[frame < 5],type(frame[frame < 5])
frame[frame < 5] = 0
frame.ix[['a','d'],['Ohio','Texas']]    --->使用ix选取元素
frame.ix[2]                             --->默认选取第三行
frame.ix[frame.Ohio > 0]                --->默认选取ohio大于0的行
frame.ix[frame.Ohio > 0,:2]             --->默认选取ohio大于0的行的前2列
 
---#5-6 DataFrame的索引选项
obj[val]                           选取DF的单个列或一组列,在一些特殊情况下比较便利:布尔型数组，切片，布尔型df
obj.ix[val]                        选取df的单个行或一组行
obj[:,val]                         选取单个列或列子集
obj[val1,val2]                     选取行和列
reindex方法                         将一个或多个轴匹配到新索引
xs方法                              根据标签选取单行或单列,并返回一个series
icol,irow                          根据整数位置选取单列或单行,并返回一个series
get_value,set_value                根据行标签和列标签选取单个值
 
frame.ix[['d'],['Texas']]          --->ix方法选取 d行 Texas列
 
 
---------------算术运算和数据对齐
s1 = Series([1,2,3],['a','b','c'])
s2 = Series([4,5,6],['b','c','d'])
df1 = DataFrame(np.arange(12.).reshape(3,4),columns=list('abcd'))
df2 = DataFrame(np.arange(20.).reshape(4,5),columns=list('abcde'))
df1 + df2                        
df1.add(df2,fill_value = 1000)                     --->函数add方法
df1.reindex(columns = df2.columns,fill_value=0)    --->reindex（df1）by DF2cols 重新索引指定填充值
 
---#5-7  灵活的算术方法
add               (+)
sub               (-)
div               (/)
mul               (*)
 
 
---------------DataFrame和Series之间的运算
arr = DataFrame(np.arange(12.).reshape((3,4)),columns = list('abcd'))
arr - arr.ix[0]      --->广播原理
Series2 = Series(range(3),index = list('cdf'))
Series2
Series3 = arr['d']
arr.sub(Series3,axis = 0)           --->列减
 
---------------函数应用和映射
frame = DataFrame(np.random.randn(4,3),columns = list('abc'),index = ['Ut','Oh','Te','Or'])
np.abs(frame)                       --->绝对值
fun = lambda x:x.max() - x.min()    --->构造函数
frame.apply(fun)                    --->应用函数
frame.apply(fun,axis = 1)           --->在行上应用函数
frame.sum(axis=1)                   --->根据行求和
frame.sum()                         --->根据列求和
def f(x):
	return Series([x.min(),x.max()],index = ['min','max'])
frame.apply(f)
 
format = lambda x: '%.2f' % x        ---->元素级的python函数也是可以用的，但是要使用applymap函数
frame.applymap(format)               ---->四舍五入
frame['b'].map(format)
 
 
---------------排序与排名sorting
obj = Series(range(4),index = ['d','a','b','c'])
obj.sort_index()                       --->对index排序
 
frame = DataFrame(np.arange(8).reshape((2,4)),index = ['three','one'],columns = ['d','a','b','c'])
frame.sort_index(axis = 1)                    --->对行排序
frame.sort_index()                            --->对列index排序 正序
frame.sort_index(axis = 1,ascending = False)  --->对列index排序 倒序
np.sort(obj)                                  --->np.sort
 
frame = DataFrame({'b':[4,7,-3,2],'a':[0,1,0,1]})
frame.sort_index(by = ['a','b'])              --->对列值排序
 
obj = Series([7,-5,7,4,2,0,4])
obj.rank(method='first')
 
obj.rank(method = 'first',ascending=False)
obj.rank(method = 'max',ascending=False)
obj.rank(method = 'min',ascending=False)
frame.rank()
frame.rank(axis=1)
 
#5-8 排名时用于破坏平级关系的method选项
average               默认:在相等分组中，为各个值分配平均排名   
min                   使用整个分组的最小排名
max                   使用整个分组的最大排名
first                 按值在原始数据中的出现顺序分配排名
 
---------------带有重复值的轴索引
obj = Series(range(5),index = list('aabbc'))
obj.index.is_unique
obj['a']
df = DataFrame(np.random.randn(4,3),index = list('aabb'))
df.ix['b']
 
---------------汇总和计算描述统计
df = DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index = list('abcd'),columns=['one','two'])
df.sum(axis=1)
df.idxmin()             -------->列最小值
df.idxmax()             -------->列最大值
df.cumsum()             -------->0行1列
df.describe()
obj = Series(['c','a','a','b','d'] * 4)
obj.index=range(1,21)
obj.describe()
 
---#简约方法的选项
axis                          轴，行=0 列=1
skipna                        排除缺失值，默认为True
level                         如果轴是层次化索引，则根据level分组简约
---#描述和汇总统计
count                         非NA的数量
describe                      针对Series或各DataFrame列计算汇总统计
min,max                       计算最小值和最大值
argmin,argmax                 计算能够取到最小值和最大值的索引位置（整数）
idmax,idmin                   计算能够取到最小值和最大值的索引值
quantile                      计算样本分位数（0到1）
sum                           值的总和
mean                          值的平均数
median                        值的算术中位数(50%分位数)
mad                           根据平均值计算平均值绝对离差
var                           样本值的方差
std                           样本值的标准差
skew                          样本值的偏度(三阶距)
kurt                          样本值的偏度(四阶距)
cumsum                        样本值的累积和
cummin,cummax                 样本值的累计最大值和累计最小值
cumpord                       样本值的累计积
diff                          计算一阶差分（timeseries）
pct_change                    计算百分数变化
 
frame = DataFrame([[1,2,3,4],[5,6,7,8],[-10,11,12,-13]],index = list('abc'),columns = ['one','two','three','four'])
frame.cummin()                默认为0 <|>
 
---------------相关系数与协方差
import pandas_datareader.data as web
all_data={}
for ticker in ['AAPL','IBM','MSFT','GOOG']:
	all_data[ticker]=web.get_data_yahoo(ticker,'1/1/2000','1/1/2010')
price=DataFrame({tic:data['Adj Close'] for tic,data in all_data.items()})
volume=DataFrame({tic:data['volume'] for tic,data in all_data.items()})
returns=price.pct_change()
returns.tail()
returns.MSFT.corr(returns.IBM)         corr用于计算2个series中重叠的，非NA的，按索对齐的值的相关系数
returns.MSFT.cov(returns.IBM)          计算协方差
returns.corr()
returns.cov()
returns.corrwith(returns.IBM)
returns.corrwith(volume)
 
---------------唯一值、值计数以及成员资格
obj = Series(['a','a','b','f','e'])
uniques = obj.unique()
uniques.sort()                 #记住这是就地排序
obj.value_counts()          --->统计计数
obj.values
pd.value_counts(obj.values,sort = False)
mask = obj.isin(['b','c'])
obj[mask]
data = DataFrame({'Qu1':[1,3,4,3,4],
                  'Qu2':[2,3,1,2,3],
                  'Qu3':[1,5,2,4,4]})
data.apply(pd.value_counts).fillna(0)
 
---#5-11 唯一值,值计数,成员资格方法
isin               计算一个表示-series各值是否包含于传入的值序列中-的布尔型数组
unique             计算series中的唯一值数组,按发现的顺序返回
value_counts       返回一个series，其所以为唯一值,其值为频率,按计数值降序排列
 
---------------处理缺失数据
str_data = Series(['a',np.nan,'b','c'])
str_data[0] = None
str_data.isnull()
str_data.notnull()
 
---#5-12 NA处理方法
dropna              根据各标签的值中是否存在缺失数据对轴标签进行过滤，通过阀值调节对缺失值的容忍度
fillna              用指定或插值方法(如ffill或bfill)填充缺失数据
isnull              饭回一个布尔值对象，这些布尔值表示那些事缺失值NA
notnull             isnull否定式
 
data = Series([1,NA,3.5,7,NA])
data.dropna()                          --->滤除缺失值
data[data.notnull()]
data1 = DataFrame([[1,2,3],[NA,2.3,4],[NA,NA,NA]])
data1.dropna()                         --->默认:除缺失值的行列 这样操作函授NA值的行列都将不存在
data1.dropna(how = 'all')              --->指定how='all' 默认axis=0 表示滤除整行为NA的行
data1.dropna(how = 'all',axis = 1)     thresh指定列
data2.ix[:4,1] = NA
data2.ix[:2,2] = NA
data2.dropna(thresh = 2)               --->thresh：按照行选取NAN的个数
data2.dropna(thresh = 4,axis = 1)
 
 
---------------填充缺失数据
df = DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index = list('abcd'),columns=['one','two'])
df.fillna(0)
data2 = DataFrame(np.random.randn(7,3))
data2.ix[:4,1] = NA
data2.ix[:2,2] = NA
data2.fillna(0)                  --->0填充，返回视图不修改
data2.fillna(0,inplace = True)   --->0填充，修改原表值
data2.fillna({1:0.5,2:-1})       --->按列分别填充
data2.fillna({1:data2.mean(0)[1],2:-data2.mean(0)[2]}) --->填充均值
df = DataFrame(np.random.randn(6,3))
df.ix[2:,1] = NA
df.ix[4:,2] = NA
df.fillna(method = 'ffill',limit = 2)
data = Series([1.2,NA,4,NA])
data.fillna(data.mean())          --->填充均值
 
---#filla函数的参数
value                    用于填充缺失值的标量值或字典对象
method                   插值方式,默认-ffill
axis                     待填充的轴,默认axis=0
inplace                  修改调用者对象而不产生副本
limit                   (对于前向和后向填充)可以连续填充的最大数量
 
---------------层次化索引（纵表转横表）
data = Series(np.random.randn(10),index=[['a','a','a','b','b','b','c','c','d','d'],[1,2,3,1,2,3,1,2,2,3]])
data.index
data['b']
data['b':'c']
data.ix[['b','d']]                  --->index为bd的
data[:,2]                           --->第一层index中第二个值
data.unstack().fillna(0)            --->基于第一层ix的第二层转成列
 
frame = DataFrame(np.arange(12).reshape((4,3)),
index = [['a','a','b','b'],[1,2,1,2]],
columns = [['Ohio','Ohio','Colorado'],['Green','Red','Green']])
frame.index.names = ['key1','key2']         --->给ix层名
frame.columns.names = ['state','color']     --->给col层名
columns = pd.MultiIndex.from_arrays([['Ohio','Ohio','Colorado'],['Green','Red','Green']],names = ['state','color'])  --->创建Multiindex复用分级
frame1 = DataFrame(np.arange(12).reshape((4,3)),columns = columns)
--------------根据级别汇总统计
frame.swaplevel('key1','key2')        --->用swaplevel重排分级顺序（接受2个级别编号或名称）#将k1,k2对换ix
frame.sortlevel(1)                    --->根据index的第二层进行排序
frame.swaplevel(1,0).sortlevel(0)     --->index的第二层和第一层对换，根据0 sortlevel进行排列
frame.sum(level = 'key2')             --->求k2层汇总
frame.sum(level = 'color',axis = 1)   --->根据color汇总
 
--------------使用DataFrame的列
frame = DataFrame({'a':range(7),'b':range(7,0,-1),'c':['one','one','one','two','two','two','two'],'d':[0,1,2,0,1,2,3]})
frame2 = frame.set_index(['c','d'])                ------>以cd为index的列
frame3 = frame.set_index(['c','d'],drop = False)   ------>以cd为列 保留cd列
frame2.reset_index()                               ------>与set_index相反的是reset_index函数
 
 
--------------其他有关pandas的话题
#-*- encoding:utf-8 -*-
import numpy as np
import os
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import pandas.io.data  as web
#这里说的是一些蛋疼的问题：整数索引和整数标签
ser = Series(np.arange(3.))
#print ser[-1]  #报错，因为整数索引的歧义性
ser2 = Series(np.arange(3.),index = ['a','b','c'])
print ser2[-1] #正确
#ix函数总是面向标签的
print ser.ix[:1]
#如果需要可靠的、不考虑索引类型的、基于位置的索引，可以使用Series的iget_value方法，Dataframe的irow 和 icol方法
ser3 = Series(range(3),index= [-5,1,3])
print ser3.iget_value(2)
frame = DataFrame(np.arange(6).reshape(3,2),index = [2,0,1])
print frame.irow(0)
 
#pandas 有一个Panel数据结构（不是主要内容），可以看作是三维的DataFrame。pandas中的多维数据可以利用多层索引进行处理
#可以利用DataFrame对象组成的字典或者一个三维ndarray来创建Panel对象
pdata = pd.Panel(dict((stk,web.get_data_yahoo(stk,'1/1/2009','6/1/2012')) for stk in ['AAPL','GOOG','MSFT','DELL']))
#网络错误，得不到数据
#Panel的每一项都是一个DataFrame.
 
与或非（交并差集）
a = t | s          # t 和 s的并集  
b = t & s          # t 和 s的交集  
c = t – s          # 求差集（项在t中，但不在s中）  
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
 
-------------------------------------------------CP6 文件存取------------------------------------------------
https://www.cnblogs.com/batteryhp/p/5021858.html
file ch06
--------------------读写文本格式数据
#pandas 中的函数
read_csv                       从文件，url，文件对象中加载带分隔符的数据，默认分隔符为逗号
read_table                     从文件，url，文件对象中加载带分隔符的数据，默认分隔符为制表符\t
read_fwf                       读取定宽格式数据(也就是说，没有分隔符)
read_clipboard                 读取粘贴板中的数据，可以看做read_table的粘贴板,将网页装换为表格时很有用
 
df=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex1.csv',index_col='message')         --->读取文件并将message列作为index
pd.read_table('C:/Users/admin/Desktop/pyda/ch06/ex1.csv',sep=',')
pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex1.csv',header=None)                    --->读取文件无列名
 
name=['a','b','c','d','me']
pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex2.csv',names=name,index_col='mes')     --->指定列名index
parsed=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/csv_mindex.csv',index_col=['key1','key2'])       --->指定层次化索引
 
#read_csv/read_table 函数的参数
path                                表示文件系统位置，url，文件型对象的字符串
sep/delimiter                       用于对行中各字段进行拆分的字符序列或正则表达式
header                              用作列名的行号，默认0(第一行)，如果没有header行就应该设置为None
index_col                           用作索引的列编号或列名.可以是单个名称/数字或多个名称/数字组成的列表(层次化索引)
names                               用于结果的列名列表,结合header=None
skiprows                            需要忽略的行数（从文件开始处算起），或需要跳过的行号列表(从0开始)
na_values                           一组用于替换NA的值
comments                            用于将注释信息从行尾拆分出去的字符(一个或多个)
parse_datas                         尝试将数据解析为日期，默认为False，如果为True。则尝试解析所有列，
                                    此外还可以指定需要解析的一组列号或列名。如果列表的元素为列表或元祖，就会将多个列组合到一起进行日期解析工作（例：时间/日期分别位于2个列中）
keep_date_col                       如果连接多列解析日期，则保持参与连接的列。默认为False
converters                          由列号/列名跟函数之间的映射关系组成的字典，例如，{'foo':f}会对foo列的所有值应用函数F
dayfirst                            当解析有歧义的日期时，将其看做国际格式(例，7/6/2012/->june 7,2012) 默认为False
data_parser                         用于解析日期的函数
nrows                               需要读取的行数
iterator                            返回一个TextParser一遍逐块读取文件
chunksize                           文件块的大小(用于迭代)
skip_footer                         需要忽略的行数(从文件末尾处算起)
verbose                             打印各种解析器输出信息,比如“非数值列中缺失值的数量”等
encoding                            用于unicode的文本编码格式,例 utf-8表示UTF-8编码的文本
squeeze                             如果数据经解析后仅含一列 则返回series
thousands                           千分位分隔符，如','或'.'
 
 
list(open('C:/Users/admin/Desktop/pyda/ch06/ex3.txt'))
result=pd.read_table('C:/Users/admin/Desktop/pyda/ch06/ex3.txt',sep='\s+')        --->非逗号(space)分隔符文件的读取
 
pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex4.csv',skiprows=[0,2,3])          --->跳过第一三四行
 
result=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex5.csv') 
result=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex5.csv',na_values=['null']) --->用字符串表示缺失值
 
sentinels={'message':['foo','NA'],'something':['two']}                            --->用字典为各列指定不同的NA值
result=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex5.csv',na_values=sentinels)
 
--------------逐块读取文件（chunksize）
result=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex6.csv')  
pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex6.csv',nrows=5)        --->取前五行
 
chunker=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex6.csv',chunksize=1000)
tot=Series([])
for price  in chunker:
	tot=tot.add(price['key'].value_counts(),fill_value=0)
tot=tot.order(ascending=False)                                        --->chunk块
 
--------------------逐块读取文件way2----------
#-*- encoding:utf-8 -*-
import numpy as np
import os
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import pandas.io.data  as web
import csv
 
f = open('ex6.csv')
reader = csv.reader(f)
for line in reader:print(line)
lines = list(csv.reader(open('ex7.csv')))
header,values = lines[0],lines[1:]
print header
print values
#下面的 * 应该是取出值的意思
data_dict = {h:v for h,v in zip(header,zip(*values))}
print(data_dict)
class my_dialect(csv.Dialect):
    lineterminator = '\n'
    delimiter = ';'
    quotechar = '"'
 
reader = csv.reader(f,dialect=my_dialect)
#csv语支的参数也可以用参数的形式给出
reader = csv.reader(f,delimiter = '|')
--------------------------------------------------------------------------------
 
---------将数据写出到文本格式
data=pd.read_csv('C:/Users/admin/Desktop/pyda/ch06/ex5.csv')
data.to_csv('C:/Users/admin/Desktop/pyda/zz.csv')            --->保存为csv
data.to_csv(sys.stdout,sep='|')                              --->保存为|分隔符
data.to_csv(sys.stdout,na_rep='NULL')                        --->输出结果中的缺失值用null或其他形式表示
data.to_csv(sys.stdout,na_rep='NULL',index=False,header=False)   ---> 
data.to_csv(sys.stdout,na_rep='NULL',index=False,cols=['a','b','c']) ---> 指定列名
dates=pd.date_range('1/1/2000',periods=7)
ts=Series(np.arange(7),index=dates)
ts.to_csv('C:/Users/admin/Desktop/pyda/ts.csv')
 
---------手工处理分隔符格式
import csv
f=open('C:/Users/admin/Desktop/pyda/ch06/ex7.csv')
reader=csv.reader(f)                  --->打开
for line in reader:
	print(line)
lines=list(csv.reader(open('C:/Users/admin/Desktop/pyda/ch06/ex7.csv')))  --->简化后代码
class my_dialect(csv.Dialect):
	lineterminator='\n'
	delimiter=';'
	quotechar='"'
reader=csv.reader(f,dialect=my_dialect)
reader=csv.reader(f,delimiter='|')
 
#6-3csv语支选项
delimiter                                     用于分隔字段的单字符字符串。默认为“,”
lineterminator                                用于写操作的行结束符，默认为‘\r\n’，读操作将忽略此选项，他能认出跨平台的行结束符
quotechar                                     用于带有特殊字符（如分隔符）的字段引用符号，默认为“
skipinitialspace                              忽略分隔符后面的空白符，默认为False
quoting                                       引用约定
doublequote                                   如何处理字段内的引用符号，如True则双写
escapechar                                    对分隔符进行转译的字符串
 
 
'''with open('C:/Users/admin/Desktop/pyda/ch06/mydata.csv','w') as f:
	writer=csv.writer(f,dialect=my_dialect)
	writer.writerow(('one','two','three'))
	writer.writerow(('1','2','3'))
	writer.writerow(('4','5','6'))
	writer.writerow(('7','8','9'))''' #python3中此代码不可用
 
 
--------------json数据
import json
df=json.loads(obj)
asjson=json.dump(obj)
sublings=DataFrame(result['sublings'],columns=['name','age'])
 
--------------XML和HTML：Web信息收集
 
--------------二进制数据文件
frame = pd.read_csv('ex1.csv')
print frame
frame.save('frame_pickle') #存储为二进制文件
ok = pd.load('frame_pickle') #load函数
#ok1 = pd.read_table('frame_pickle') #不能用read_table函数
#print ok1
print ok
 
--------------读取Excel数据（详见uexcel）
xls_file = pd.ExcelFile('ex1.xlsx')
table = xls_file.parse('ex1')
print table
 
----------------------------------------C7数据规整化：清洗 转换 合并 重塑----------------------------------------
https://www.cnblogs.com/virusolf/p/6226296.html
#encoding=gbk
import numpy as np 
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
import re
 
-----------------------------DataFrame合并
df1 = DataFrame({'key':['b','b','a','c','a','a','b'],'data1':range(7)})
df2 = DataFrame({'key':['a','b','d'],'data2':range(3)})
pd.merge(df1,df2)                   ---合并df1和df2，默认为inner（内连接）
pd.merge(df1,df2,on = 'key')        ---合并键为key
pd.merge(df1,df2,how = 'outer')     ---笛卡尔积合并
---分别指定对象列名
df3 = DataFrame({'lkey':['b','b','a','c','a','a','b'],'data1':range(7)})
df4 = DataFrame({'rkey':['a','b','d'],'data2':range(3)})
pd.merge(df3,df4,left_on = 'lkey',right_on = 'rkey')   ---当连接写的key在各自df中名称不同时指定左右既可
---对多个键进行合并
left = DataFrame({'key1':['foo','foo','bar'],'key2':['one','two','one'],'lval':[1,2,3]})
right = DataFrame({'key1':['foo','foo','bar','bar'],'key2':['one','one','one','two'],'rval':[4,5,6,7]})
pd.merge(left,right,on = ['key1','key2'],how = 'outer')
 
---通过suffixes选项指定后缀
pd.merge(left,right,on = 'key1',suffixes = ('_left','_right'))
 
#merge函数中的参数
left                                     合并左侧
right                                    合并右侧
how                                      inner,outer,left,right其中之一,默认inner
on                                       用于连接的列名。必须存在于左右2个df对象中。如果未指定 且其他键也未指定，则以left和right列名的交集作为连接键
left_on                                  左侧df用作连接键的列
right_on                                 右侧df用作连接键的列
left_index                               将左侧的行索引用作连接键
right_index                              同上-右侧
sort                                     根据连接键对合并后的数据进行排序，默认为True.有时处理太体量数据集时 禁用可以获得更高的性能
suffixes                                 字符串元组,用于追加到重叠列名的末尾,默认为('_x','_y'),例如左右2个df都有data字段 则合并后为data_x,data_y
copy                                     设置为False,可以
 
-----------------------------索引上的合并
DataFrame中连接键有时候在索引中。这时可以传入left_index = True或者right_index = True
left1 = DataFrame({'key':list('abaabc'),'value':range(6)})
right1 = DataFrame({'group_val':[3.5,7]},index=['a','b'])
pd.merge(left1,right1,left_on = 'key',right_index = True,how = 'inner')
pd.merge(left1,right1,left_on = 'key',right_index = True,how = 'outer').fillna(0)
 
---层次化索引  合并
lefth = DataFrame({'key1':['Ohio','Ohio','Ohio','Nevada','Nevada'],
    'key2':[2000,2001,2002,2001,2002],'data':np.arange(5.)})
righth = DataFrame(np.arange(12.).reshape((6,2)),index = [['Nevada','Nevada','Ohio','Ohio','Ohio','Ohio',],
    [2001,2000,2000,2000,2001,2002]],columns = ['event1','event2'])
pd.merge(lefth,righth,left_on = ['key1','key2'],right_index = True,how = 'outer')
 
---同时使用合并双方的索引也没问题
left2 = DataFrame([[1.,2.],[3.,4.],[5.,6.]],index = ['a','c','e'],columns = ['Ohio','Nevada'])
right2 = DataFrame([[7.,8.],[9.,10.],[11.,12.],[13,14]],index = ['b','c','d','e'],columns = ['Missouri','Alabama'])
pd.merge(left2,right2,how = 'outer',left_index = True,right_index = True)
---左连接
left2.join(right2,how = 'outer'，on='key')
another = DataFrame([[7.,8.],[9.,10.],[11.,12.],[16.,17.]],index = ['a','c','e','f'],columns = ['New York','Oregon'])
left2.join([right2,another],how = 'outer')
---轴向连接p194
arr=np.arange(12).reshape((3,4))
np.concatenate([arr,arr],axis=1)     -->横向拼接
s1=Series([0,1],index=['a','b'])
s2=Series([2,3,4],index=['c','d','e'])
s3=Series([5,6],index=['f','g'])
pd.concat([s1,s2,s3],axis=1)
s4=pd.concat([s1*5,s3])
pd.concat([s1,s4],axis=1,join_axes=[['a','c','b','e']]) -->同index
result=pd.concat([s1,s1,s3],keys=['one','two','three'])
result.unstack()  -->堆叠
pd.concat([s1,s2,s3],axis=1,keys=['one','two','three'])
--df合并
df1=DataFrame(np.arange(6).reshape(3,2),index=['a','b','c'],columns=['three','four'])
df2=DataFrame(5+np.arange(4).reshape(2,2),index=['a','c'],columns=['three','four'])
pd.concat([df1,df2],axis=1,keys=['l1','l2'])
pd.concat({'l1':df1,'l2':df},axis=1)
--层次化索引
pd.concat([df1,df2],axis=1,keys=['l1','l2'],names=['upper','lower'])
--ignore 原有索引
df3=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])
df4=DataFrame(np.random.randn(2,3),columns=['a','b','d'])
pd.concat([df3,df4],ignore_indes=True)
--根据index交集合并
pd.concat([df3,df4],join='inner')
 
#concat中的参数
objs                            参与连接的pandas对象的列表或字典
axis                            轴向练级，默认为0
join                            inner/outer 默认为outer。指明其他轴上的索引是按交集inner还是并集outer进行合并
join_axes                       指明用于其他n-1条轴的索引,不执行交/并集运算
keys                            与连接对象有关的值,用于形成连接轴上的层次化索引
levels                          指定用作层次化索引各级别上的索引,如果设置了keys和levels的话
names                           创建分层级别名称
verify_integrity                检查结果对象新轴上的重复情况,如果发现则引发异常,默认False
ignore_index                    忽略原连接轴上索引
 
 
-----------------合并重叠数据
a=Series([np.nan,2.5,np.nan,3.5,4.5,np.nan],index=['f','e','d','c','b','a'])
b=Series(np.arange(len(a),dtype=np.float64),index=['f','e','d','c','b','a'])
 
--Series的combine_first方法
b[:-2].combine_first(a[2:])
df1.combine_first(df2)      -->类似于打补丁,如果df1为空,则用df2补足df1
 
-----重塑层次化索引
data=DataFrame(np.arange(6).reshape((2,3)),index=pd.Index(['ohio','colorado'],
name='state'),columns=pd.Index(['one','two','three'],name='number'))
result=data.stack()
result.unstack(0)       轴变换
df=DataFrame({'L':result,'R':result+5},columns=pd.Index(['L','R'],name='side'))
df.unstack('stste').stack('side')
索引对换结合unstack使用
df.unstack('stste').stack('side').swaplevel(1,0).sortlevel(0)
 
-----剔除重复数据
data=DataFrame({'k1':['one']*3+['two']*4,'k2':[1,1,2,3,3,4,4]})
data.duplicated()
data.drop_duplicates()          -->去重（默认为保留第一个出现的值）
data['v1']=range(7)             -->加个v1列
data.drop_duplicates(['k1'])    -->根据k1列去重
data.drop_duplicates(['k1','k2'],take_last=True)  -->默认取最后一个值
 
-----------------------------利用函数或映射进行数据转换 map
data=DataFrame({'food':['bacon','pulled pork','bacon','pastrami',
'corned beef','Bacon','pastrami','honey ham','nova lox'],
'ounce':[4,3,12,6,7.5,8,3,5,6]})
meat={'bacon':'pig','pulled pork':'pig','pastrami':'cow','honey ham':'pig',
'nova lox':'salmon','corned beef':'cow'}
data['animal']=data['food'].map(str.lower).map(meat)  -->map映射(类似于vlookup)
data['food'].map(lambda x:meat[x.lower()])
 
-----------替换值
d=Series([1,22,3,99,-1,2,4])
d.replace([99,3],np.nan)
d.replace([99,3],[np.nan,0])
 
-----------重命名索引轴
轴标签可以通过函数或映射来转换
da=DataFrame(np.arange(12).reshape((3,4)),index=['ohio','colorado','new york'],
columns=['one','two','three','four'])
da.index=da.index.map(str.upper)                 -->对da的index 进行map-upper处理
da.columns=da.columns.map(str.upper)             -->对da的columns 进行map-upper处理
da.rename(index=str.title,columns=str.upper)     -->也可以对标签进行rename操作
da.rename(index={'OHIO':'INDIAN'},columns={'THREE':'peekaboo'})
_=da.rename(index={'OHIO':'INDIAN'},inplace=True)
 
 
-----------------------------离散化和原面划分
常见使用有 根据年龄段切分
ages=[20,22,25,27,24,26,35,37,39,45,66,45,98,25,33]
bins=[18,25,35,60,100]
cat=pd.cut(ages,bins)                          --->pd.cut(a,b)函数：list-a 根据b的规则切分
pd.value_counts(cat)                           --->实现年龄分段统计
--->pd.value_counts(pd.cut(ages,bins))
pd.cut(ages,[18,26,36,61,100],right=False)     --->类似区间符号,(18..100] right为闭端
group_names=['younth','youngadult','middleaged','senior']
--->pd.value_counts(pd.cut(ages,bins,labels=group_names))  --->实现分段统计并修改段名
d2=np.random.rand(20)
pd.cut(d2,4,precision=2)                       --->根据d2最大最小值计算等长元面,并4等分,保留2位小数
 
d3=np.random.randn(1000)
cats=pd.qcut(d3,4)                             --->qut:按照样本分位数切割
--->pd.value_counts(pd.qcut(np.random.randn(1000),4))
pd.qcut(d3,[0,0.1,0.5,0.9,1])                  --->自定义分位数
 
 
-----------------------------检测和过滤异常值
np.random.seed(12345)
data=DataFrame(np.random.randn(1000,4))
data.describe()                                --->数据描述
col=data[3]
col[np.abs(col)>3]                             --->选取abs>3的值
data[np.abs(data)>3]=np.sign(data)*3           --->sign函数 -1 0 1
-----------排列和随机采样(np.random.permutation)
df=DataFrame(np.arange(5*4).reshape((5,4)))
samper=np.random.permutation(5)                --->创建随机数
df.take(samper)                                --->进行(take)随机采样
--->df.take(np.random.permutation(len(df))[:3])   
bag=np.array([5,7,-1,6,4])
sampler=np.random.randint(0,len(bag),size=10) --->randint(a,b,c) 随机抽取a-b之间的c个数
draw=bag.take(sampler)
基本逻辑是 take() 出np.random.permutation() 随机出的列标 
->bag=np.array([5,7,-1,6,4])
-->draw=bag.take(np.random.randint(0,len(bag),size=10))
 
 
-----------------------------计算指标/哑变量
df=DataFrame({'key':['b','b','a','c','a','b'],'data1':range(6)})
pd.get_dummies(df['key'])
dummies=pd.get_dummies(df['key'],prefix='key')   --->给变量加一个前缀
df_with_dummy=df[['data1']].join(dummies)    
---结合get_dummies和cut
pd.get_dummies(pd.cut(np.random.rand(10),[0,0.2,0.4,0.6,0.8,1]))
 
 
-----------------------------字符串对象方法
v='a,b,zieox'
v.split(',')                               --->split 
pieces=[x.strip() for x in v.split(',')]   --->strip 用于修剪空白符(换行符)
first,second,third=pieces                  --->将列标中的值赋给f s t
first+'::'+second+'::'+third               --->拼接
或者
'::'.join(pieces)                          --->join拼接方法
v.count(',')                               --->count方法 类似select count(',') from v
v.replace(',','-')                         --->replace方法
 
#python内置的字符串方法
count                                        count
endswith/startswith(v)                       如果字符串以v结尾/开始则返回true,例 v.startswith('a')
join                                         join拼接方法,'+'.join(pieces) ->a+b+zieox
index                                        查找字符在字符串内位置,v.index('o')->7 字符不在字符串内则报错
find                                         与index一样,不过若字符不在字符串内则返回-1
rfind                                        如果找到,返回第一个找到的位置
replace                                      替换 v.replace('a','A')
strip/rstrip/lstrip                          去除空白符(左/右)
split                                        拆分
lower/upper                                  全小/大写
ljust/rjust                                  用空格(或其他字符)填充字符串的空白处返回最低宽度字符要求
                                             类似impala中的兰帕德函数,lpad(str,10,'-') ->select lpad('apple',10,'-')   
 
----------------------------------------正则表达式----------------------------------------
t='i have\t an \tapple'
re.split('\s+',t)
 
http://www.runoob.com/python3/python3-reg-expressions.html
https://www.cnblogs.com/dyfblog/p/5880728.html
#re
一.元字符 （参见 python 模块 re 文档）
 
.                                            匹配任意字符（不包括换行符）
^                                            匹配开始位置，多行模式下匹配每一行的开始
$                                            匹配结束位置，多行模式下匹配每一行的结束
*                                            匹配前一个元字符0到多次
+                                            匹配前一个元字符1到多次
?                                            匹配前一个元字符0到1次
{m,n}                                        匹配前一个元字符m到n次
\\                                           转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\\.只能匹配.，不能再匹配任意字符
[]                                           字符集，一个字符的集合，可匹配其中任意一个字符
|                                            逻辑表达式 或 ，比如 a|b 代表可匹配 a 或者 b
(...)                                        分组，默认为捕获，即被分组的内容可以被单独取出，默认每个分组有个索引，从 1 开始，按照"("的顺序决定索引值
(?iLmsux)                                    分组中可以设置模式，iLmsux之中的每个字符代表一个模式,用法参见 模式 I
(?:...)                                      分组的不捕获模式，计算索引时会跳过这个分组
(?P<name>...)                                分组的命名模式，取此分组中的内容时可以使用索引也可以使用name
(?P=name)                                    分组的引用模式，可在同一个正则表达式用引用前面命名过的正则
(?#...)                                      注释，不影响正则表达式其它部分,用法参见 模式 I
(?=...)                                      顺序肯定环视，表示所在位置右侧能够匹配括号内正则
(?!...)                                      顺序否定环视，表示所在位置右侧不能匹配括号内正则
(?<=...)                                     逆序肯定环视，表示所在位置左侧能够匹配括号内正则
(?<!...)                                     逆序否定环视，表示所在位置左侧不能匹配括号内正则
(?(id/name)yes|no)                           若前面指定id或name的分区匹配成功则执行yes处的正则，否则执行no处的正则
\number                                      匹配和前面索引为number的分组捕获到的内容一样的字符串
\A                                           匹配字符串开始位置，忽略多行模式
\Z                                           匹配字符串结束位置，忽略多行模式
\b                                           匹配位于单词开始或结束位置的空字符串
\B                                           匹配不位于单词开始或结束位置的空字符串
\d                                           匹配一个数字， 相当于 [0-9]
\D                                           匹配非数字,相当于 [^0-9]
\s                                           匹配任意空白字符， 相当于 [ \t\n\r\f\v]
\S                                           匹配非空白字符，相当于 [^ \t\n\r\f\v]
\w                                           匹配数字、字母、下划线中任意一个字符， 相当于 [a-zA-Z0-9_]
\W                                           匹配非数字、字母、下划线中的任意字符，相当于 [^a-zA-Z0-9_]
 
二.模式
I                                 IGNORECASE， 忽略大小写的匹配模式, 样例如下
s = 'hello World!'
 
regex = re.compile("hello world!", re.I)
regex.match(s).group()
#output> 'Hello World!'
 
#在正则表达式中指定模式以及注释
regex = re.compile("(?#注释)(?i)hello world!")
print regex.match(s).group()
#output> 'Hello World!'
 
M                                  MULTILINE，多行模式, 改变 ^ 和 $ 的行为
 
s = '''first line second line third line'''
# ^
regex_start = re.compile("^\w+")
regex_start.findall(s)
# output> ['first']
 
regex_start_m = re.compile("^\w+", re.M)
regex_start_m.findall(s)
# output> ['first', 'second', 'third']
 
#$
regex_end = re.compile("\w+$")
regex_end.findall(s)
# output> ['line']
 
regex_end_m = re.compile("\w+$", re.M)
regex_end_m.findall(s)
# output> ['line', 'line', 'line']
 
S                                   DOTALL，此模式下 '.' 的匹配不受限制，可匹配任何字符，包括换行符
s = '''first line second line third line'''
 
regex = re.compile(".+")
regex.findall(s)
# output> ['first line', 'second line', 'third line']
 
# re.S
regex_dotall = re.compile(".+", re.S)
regex_dotall.findall(s)
# output> ['first line\nsecond line\nthird line']
 
 
 
----------------------USDA食品数据库范例
import json
db=json.load(open('E:/work/qbao/PY-W-new/pydata-book-master/ch07/foods-2011-10-03.json'))
len(db)
db[0].keys()                                --->查看列表title
key=[ i for i in db[0].keys()]
db[0]['nutrients'][0]                       --->查看nutrients下的结构
nutrients=DataFrame(db[0]['nutrients'])     --->将nutritients载入df 
info_key=['description','group','id','manufacture']   
info=DataFrame(db,columns=info_key)         --->读取db并取出相应列
pd.value_counts(info.group)[:10]            --->统计group信息
n=[]
for rec in db:
	funts=DataFrame(rec['nutrients'])
	funts['id']=rec['id']
	n.append(funts)
nutrients=pd.concat(n,ignore_index=True)
nutrients.duplicated().sum()                --->去重
nutrients=nutrients.drop_duplicates()       --->丢弃
col_mapping={'description':'food','group':'fgroup'}
info=info.rename(columns=col_mapping,copy=False)
col={'description':'nutrient','group':'nutgroup'}
nutrients=nutrients.rename(columns=col,copy=False)
ndata=pd.merge(nutrients,info,on='id',how='outer')       --->合并nutrients和info
ndata.ix[30000]
---
result=ndata.groupby(['nutrient','fgroup'])['value'].quantile(0.5)
#result['Zinc, Zn'].order().plot(kind='barh')
by_nutrient=ndata.groupby(['nutgroup','nutrient'])
get_max=lambda x: x.xs(x.value.idmax())
get_min=lambda x: x.xs(x.value.idmin())
#max_foods=by_nutrient.apply(get_max)[['value','food']]
max_foods.food=max_foods.food.str[:50]
 
---------------------------------------------C8 绘图可视化---------------------------------------------
------matplotlib
matplotlib官方文档 https://matplotlib.org/
#---figure和subplot
import matplotlib.pyplot as pl
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
fig=pl.figure()        
#定义一个图
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
ax3=fig.add_subplot(2,2,3)
#画一个2*2*3的subplot
 
#建一个2行3列的subplot
fig=pl.figure()  
fig,axes=pl.subplots(2,3)
 
#在2*2 3 的版面上画一个虚线图 一个hist 一个虚线图
from numpy.random import randn
fig=pl.figure() 
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
ax3=fig.add_subplot(2,2,3)
pl.plot(randn(50).cumsum(),'k--')
_ =ax1.hist(randn(100),bins=20,color='k',alpha=0.3)
ax2.scatter(np.arange(30),np.arange(30)+randn(30))
 
#---pyplot.subplots的选项
nrows                                      subplot的行数
ncols                                      subplot的列数
sharx                                      共享x轴
shary                                      共享y周
subplot_kw                                 用于创建各subplot的关键字字典
**fig_kw                                   创建figure时的其他关键字，如plt.subplots(2,2,figesiz=(8,6))
#调整subplot周围的距离
#wspace和hspace用于调整宽高百分比
subplot_adjust(left=None,bottom=None,right=None,top=None,wspace=None,hspace=None)
fig,axes=pl.subplots(2,2,sharey=True)
for i in range(2):
	for j in range(2):
		axes[i,j].hist(randn(50),bins=50,color='k',alpha=0.5)
pl.subplots_adjust(wspace=0,hspace=0)
 
#---颜色,标记和线型
ax.plot(x,y,linestyle='--',color='g')
#plot 线条样式参数
字符               描述
-	               实线
--	               虚线
-.	               点线
:	               点虚线
.	               点
,	               像素
o	               圆形
v	               朝下的三角形
^	               朝上的三角形
<	               朝左的三角形
>	               朝右的三角形
1	               tri_down marker
2	               tri_up marker
3	               tri_left marker
4	               tri_right marker
s	               正方形
p	               五角形
*	               星型
h	               1号六角形
H	               2号六角形
+	               +号标记
x	               x号标记
D	               钻石形
d	               小版钻石形
|	               垂直线形
_	               水平线行
ko--               点线
 
#线条颜色参数
字符                颜色
b 	               蓝色
g	               绿色
r	               红色
c	               青色
m	               品红
y	               黄色
k	               黑色
w	               白色
RGB色参数
https://www.cnblogs.com/darkknightzh/p/6117528.html
#带标记的线型图
pl.plot(randn(30).cumsum(),'ko--')           
pl.plot(randn(30).cumsum(),color='k',linestyle='dashed',marker='o')
#
data=randn(30).cumsum()
pl.plot(data,'k--',label='Default')
pl.plot(data,'k-',drawstyle='steps-post',label='step-post')
pl.legend(loc='best')
 
#刻度,标签和图例
xlim,xticks,xticklabels
ax.set_xlim,ax.set_xlim
 
#设置标题,轴标签,刻度及刻度线
fig=pl.figure()
ax=fig.add_subplot(1,1,1)
ax.plot(randn(1000).cumsum())
 
#设置x,y轴刻度,轴标签,表名title
ticks=ax.set_xticks([0,250,500,750,1000])
labels=ax.set_xticklabels(['one','two','three','four','five'],rotation=30,fontsize='small')
ax.set_title('made by :zieox')
ax.set_xlabel('stage')
 
#添加图例(legend) 
fig=pl.figure()
ax=fig.add_subplot(1,1,1)
ax.plot(randn(1000).cumsum(),'k',label='one',color='y')
ax.plot(randn(1000).cumsum(),'k--',label='two',color='b')
ax.plot(randn(1000).cumsum(),'k.',label='three',color='r')
ax.legend(loc='best')
 
#注解以及在subplot上绘图
ax.text(x,y,'hello word',family='monospace',fontszie=10)
 
#例：给 2008-2009年金融危机期间的重要日期 加上标注
from datetime import datetime
fig=pl.figure() 
ax=fig.add_subplot(1,1,1)
data=pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch08/spx.csv',index_col=0,parse_dates=True)
spx=data['SPX']
spx.plot(ax=ax,style='k-')
crisis_data=[(datetime(2017,10,11),'peak of bull market'),
(datetime(2008,3,12),'bear stearns fails'),
(datetime(2008,9,15),'lehman bankruptcy')]
for date,label in crisis_data:
	ax.annotate(label,xy=(date,spx.asof(date)+50),
	xytext=(date,spx.asof(date)+200),
	arrowprops=dict(facecolor='black'),
	horizontalalignment='left',verticalalignment='top')
#|放大到2017-2010
ax.set_xlim(['1/1/2007','1/1/2011'])
ax.set_ylim([600,1800])
ax.set_title('import dates in 2008-2009 fincial crisis')
ax.set_title('Important dates in 2008-2009 finacial crisis')
pl.show()
 
#绘制图形 长方形 椭圆 三角
fig = pl.figure()
ax = fig.add_subplot(1,1,1)
rect = pl.Rectangle((0.2,0.75),0.4,0.15,color = 'k',alpha = 0.3)
circ = pl.Circle((0.7,0.2),0.15,color = 'b',alpha = 0.3)
pgon = pl.Polygon([[0.15,0.15],[0.35,0.4],[0.2,0.6]],color = 'g',alpha = 0.5)
ax.add_patch(rect)
ax.add_patch(circ)
ax.add_patch(pgon)
pl.show()
 
#将图标保存到文件
pl.save('C:/desktop/image.svg',dpi=400,bbox_inches='tight')
#不一定save到文件中，也可以写入任何文件型对象，比如StringIO：
buffer = StringIO()
plt.savefig(buffer)
plot_data = buffer.getvalue()
 
#figure.savefig选项
fname                   含有文件路径的字符串或python的文件类型
dpi                     图像分辨率（每英寸点数）默认100
faceolor,edgrcolor      图像的背景色，默认为‘w’
format                  显式设置文件格式(png,pdf,svg,ps,eps)
bbox_inches             图表需要保存的部分，如果设置为tight，则将尝试剪除图表周围的空白部分
 
#matplotlib配置
pl.rc('figure',figsize=(10,10))
font_options={'family':'monospace','weight':'blod','size':'small'}
pl.rc('font',**font_options)
 
#例 1列2行的排版
fig=pl.figure()
ax=fig.add_subplot(1,1,1)
ax2=fig.add_subplot(2,1,1)
ax.plot(randn(1000).cumsum())
ax2.plot(randn(500))
 
------pandas 中的绘图函数
#style见上方
s=Series(np.random.rand(10).cumsum(),index=np.arange(0,100,10))
s.plot()
 
#Series.plot方法参数
label                  用于图例标签
ax                     要在ax上绘制matplotlib subplot对象,如果没有设置 则使用当前m s
style                  将要传给matplotlib的风格字符
alpha                  图表的不透明度
kind                   可以是'line','barh','kde'
logy                   在Y轴上使用对数标尺
use_index              将对象的索引用作刻度标签
rot                    旋转刻度标签(0到360)
xticks                 用作x轴刻度值
yticks                 用作y轴刻度值
xlim                   x轴的界限（例[0,10]）
ylim                   Y轴的界限
grid                   显示轴网络
#DataFrame的plot参数
subplots               将各个DataFrame；列绘制到单独的subplot中
sharex                 if sharx=True 则共享x轴刻度和界限
sharey                 if shary=True 则共享y轴刻度和界限
figsize                表示图像大小的元祖
title                  表示图像标题的字符串
legend                 添加一个subplot图例(默认为True)
sort_columns           以字母表顺序绘制各列,默认使用当前列顺序
 
#2行1列的subplots
fig,axes=pl.subplots(2,1)
data=Series(np.random.rand(16),index=list('abcdefghijklmnop'))
data.plot(kind='bar',ax=axes[0],color='k',alpha=0.7)
data.plot(kind='barh',ax=axes[1],color='k',alpha=0.7)
#df绘图
df=DataFrame(np.random.rand(6,4),index=['one','two','three','four','five','six'],
columns=pd.Index(['A','B','C','D'],name='Genus'))
df.plot(kind='bar')
 
#例:DataFrame百分比占比图
tips=pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch08/tip.csv')
party_counts=pd.crosstab(tips.day,tips.size)
party_counts=party_counts.ix[:,2:5]
#然后进行归一化是各行和为1
party_pcts = party_counts.div(party_counts.sum(1).astype(float),axis = 0)
print party_pcts
party_pcts.plot(kind = 'bar',stacked = True)
plt.show()
 
 
 
-----直方图和密度图hist
#平均小费百分比
#add column tip_pct
tips['tip_pct']=tips['tip']/tips['total_bill']
tips['tip_pct'].hist(bins=50)
tips['tip_pct'].plot(kind='kde')                --->小费百分比密度图
#曲线+hist图
comp1 = np.random.normal(0,1,size = 200)
comp2 = np.random.normal(10,2,size = 200)
values = Series(np.concatenate([comp1,comp2]))
values.hist(bins = 100,alpha = 0.3,color = 'k',normed = True)
values.plot(kind = 'kde',style = 'k--')
 
#散布图
macro=pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch08/macrodata.csv')
data = macro[['cpi','m1','tbilrate','unemp']]
trans_data = np.log(data).diff().dropna()
pl.scatter(trans_data['m1'],trans_data['unemp'])
pl.title('Changes in log %s vs. log %s'%('m1','unemp'))
 
pd.scatter_matrix(trans_data,diagonal = 'kde',color = 'k',alpha = 0.3)
pd.scatter_matrix(trans_data,diagonal = 'hist',color = 'k',alpha = 0.3)
pl.show()
 
--------------------------------------------DS-CP3
#example-matplotlib
from matplotlib import pyplot as pl
year=[1950,1960,1970,1980,1990,2000,2010]
gdp=[300.2,543.3,1075.9,2862.5,5979.6,10289.7,14958.3]
pl.plot(year,gdp,color='green',marker='o',linestyle='solid')
pl.title('name-GDP')
pl.ylabel('billion$')
pl.show()
 
------bar (条形图)
#coding:utf-8
movies=['old boy','revenages','iron-man','starwar','HelloKitty']
num_oscars=[11,65,53,26,11]
#在3.6中此操作将条形放置于中心左侧
xs=[i+0.1 for i ,_ in enumerate(movies)]
pl.bar(xs,num_oscars)
pl.ylabel('num of get_oscar')
pl.title('my favourite movie')
pl.xticks([i+0.5 for i ,_ in enumerate(movies)],movies)
pl.show()
 
#example3
from collections import Counter
grades=[86,45,46,79,13,49,79,65,35,46]
#//取整
decile=lambda grade:grade//10*10
#用counter计数器计数
histgram=Counter(decile(grade) for grade in grades)
#分别按照histgrame的key和value计数值作图,其中设置宽度为8
pl.bar([x for x in histgram.keys()],histgram.values(),8)
#设置x,y轴取值范围
pl.axis([-5,105,0,5])
#设置x轴的标记点
pl.xticks([10*i for i in range(11)])
pl.xlabel('+scorelike')
pl.ylabel('num of students')
pl.title('score-pic')
pl.show()
 
#example4
mentions=[500,505]
years=[2013,2014]
pl.bar(years,mentions,0.8)
pl.xticks(years)
pl.ylabel('mentioned ds')
pl.ticklabel_format(useOffset=False)
pl.axis([2012.5,2014.5,499,506])
pl.title('look this is a big change')
pl.show()
#now we set x,y -value_range
pl.axis([2013,2015,0,550])
pl.show()
 
------line picture (线图)
'''#easy_way
varience=[2**(i-1) for i in range(1,10)]
bias_aquared=sorted(varience,reverse=True)'''
varience=[1, 2, 4, 8, 16, 32, 64, 128, 256]
bias_aquared=[256, 128, 64, 32, 16, 8, 4, 2, 1]
total_error=[x+y for x,y in zip(varience,bias_aquared)]
xs=[i for i ,_ in enumerate(varience)]
pl.plot(xs,varience,'g-',label='varience')
pl.plot(xs,bias_aquared,'r-.',label='bias^2')
pl.plot(xs,total_error,'b:',label='total_error')
#loc=9指(tag框)顶部中央
pl.legend(loc=9)
pl.xlabel('model-complex_value')
pl.title('bias - var picture')
pl.show()
 
------scatter 散点图
import random
'''friends=[random.randint(1,100) for _ in range(10)]
minutes=[random.randint(100,200) for _ in range(10)]'''
#这里我们不用随机数
friends=[61, 73, 80, 93, 13, 26, 57, 59, 88, 84]
minutes=[157, 184, 101, 198, 196, 158, 178, 150, 113, 154]
labels=['a','b','c','d','e','f','g','h','i','j']
pl.scatter(friends,minutes)
 
for label,friend_count,minute_count in zip(labels,friends,minutes):
pl.annotate(label,
xy=(friend_count,minute_count),
xytext=(-5,5),
textcoords='offset points')
pl.title('num_minutes&friends')
pl.xlabel('num of friend')
pl.ylabel('minutes of spending')
pl.show()
 
 
'''#在这里我们实验一下在轴上放置tag,利用annotate,xytext为位移,axis为xy轴的值域
pl.bar([i for i in range(10)],minutes)
pl.axis([-1,10,0,200])
for label,i,j in zip(labels,[i for i in range(10)],minutes):
pl.annotate(label,
xy=(i,j),
xytext=(-5,5),
textcoords='offset points')'''
 
-------------------------------------------------CP9 数据聚合分组------------------------------------------------
----------------------------------cp9数据聚合与groupby
https://www.cnblogs.com/virusolf/p/6259614.html
-------简单实例
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt 
from pandas import Series,DataFrame
df=DataFrame({'key1':list('aaba'),'key2':['one','two','one','two','one'],
'data1':np.random.randn(5),'data2':np.random.randn(5)})
grouped=df['data1'].groupby(df['key1'])
#对data1列 聚合根据key1为分组键
print(grouped.mean())
means=df['data1'].groupby([df['key1'],df['key2']]).mean()
#对data1列 聚合根据key1,key2为分组键
print(means.unstack())
 
states=np.array(['ohio','california','Ohio','Ohio'])
years=np.array([2005,2005,2006,2005,2006])
df['data1'].groupby([states,years]).mean()
#根据指定键进行分组
 
df.groupby('key1').mean()
df.groupby(['key1','key2']).mean()
df.groupby(['key1','key2']).size()
 
 
-------对分组进行迭代
df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
'data1':np.random.randn(5),'data2':np.random.randn(5)})
 
print df.groupby('key1')
for name,group in df.groupby('key1'):
    print('one')
    print(name)
    print(group,'\n')
 
#多重键的情况，元组的第一个元素将会是由键值组成的元组,下面会打印四个two
#也就是说，下面的三个print是一个组合，打印key值这一点挺好
for (k1,k2),group in df.groupby(['key1','key2']):
    print 'two'
    print k1,k2
    print group,'\n'
 
#当然，可以对数据片段进行操作
#转换为字典，应该是比较有用的一个转换方式
list(df.groupby('key1'))
pieces=dict(list(df.groupby('key1')))
pieces['a']
type(pieces['a'])
pieces['a'][['data1','data2']]
#group by 默认在axis=0上进行分组,也可以在任何轴上分组
df.dtypes
grouped=df.groupby(df.dtypes,axis=1)
dict(list(grouped))                                 #将grouped装入dict
 
-------选取一个或一组列
df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
df.groupby('key1')['data1'] 
df.groupby('key1')[['data1']]
#语法糖
df['data1'].groupby(df['key1'])
df[['data1']].groupby(df['key1'])
#尤其对于大数据集，可能只是对部分列进行聚合。比如，想计算data2的均值并返回DataFrame
df.groupby(['key1','key2'])[['data2']].mean()
 
-------通过字典或Series进行分组
people = DataFrame(np.random.randn(5,5),columns = ['a','b','c','d','e'],
index = ['Joe','Steve','Wes','Jim','Travis'])
people.ix[2:3,['b','c']] = np.nan               #加点NaN
#假设已经知道列的分组方式，现在需要利用这个信息进行分组统计：
mapping = {'a':'red','b':'red','c':'blue','d':'blue','e':'red','f':'orange'}
#下面为groupby传入一个已知信息的字典
by_column = people.groupby(mapping,axis = 1)
by_column.sum()
map_series = Series(mapping)
people.groupby(map_series,axis = 1).count()
 
-------利用函数进行分组
people=DataFrame(np.random.randn(5,5),columns=['a','b','c','d','e'],
index=['joe','steve','wes','jim','travis'])
people.groupby(len).sum()                           #根据名字长度相同的人进行加和
 
#将函数、数组、字典、Series混用也ok，因为最终都会转换为数组
key_list = ['one','one','one','two','two']
people.groupby([len,key_list]).min()
 
-------根据索引级别分组
#层次化索引数据集最方便的地方就在于它能够根据索引级别进行聚合。要实现该目的，只要通过level关键字传入级别编号或名称即可
columns = pd.MultiIndex.from_arrays([['US','US','US','JP','JP'],[1,3,5,1,3]],names = ['cty','tenor'])
hier_df = DataFrame(np.random.randn(4,5),columns = columns)
print (hier_df)
print (hier_df.groupby(level = 'cty',axis = 1).count())
print (hier_df.groupby(level = 'tenor',axis = 1).count())
print (hier_df.groupby(level = ['cty','tenor'],axis = 1).count())
 
-------数据聚合
df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
grouped = df.groupby('key1')
grouped['data1'].quantile(0.9)     #切片
#对于自己定义的聚合函数，只需将其传入aggregate或agg即可
def peak_to_peak(arr):
    return arr.max() - arr.min()
print grouped.agg(peak_to_peak),
 
grouped.describe()             #有些方法（describe）也是可以应用的
 
#经过优化的groupby的方法
count                             分组中非NA值得数量
sum                               非NA和
mean                              非NA均值
median                            非NA的算术中位数
std,var                           无偏（分母为n-1）标准差和方差
min,max                           非NA值 最大 最小
prod                              非NA值得积
first,last                        第一个和随后一个非NA值
 
-------面向列的多函数应用
tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
print (tips.head())
grouped = tips.groupby(['sex','smoker'])
grouped_pct = grouped['tip_pct']
print(grouped_pct.agg('mean'))
 
#若传入一组函数或函数名，得到的DataFrame的列就会以相应的函数命名
def peak_to_peak(arr):
    return arr.max() - arr.min()
print(grouped_pct.agg(['mean','std',peak_to_peak]))             #对比例这一列应用三个函数
 
#上面有个问题就是列名是自动给出的，以函数名为列名，若传入元组
#（name，function）组成的列表，就会自动将第一个元素作为列名
print (grouped_pct.agg([('foo','mean'),('bar',np.std)]))        #注意np.std不能加引号
 
#还可以对多列应用同一函数
functions = ['count','mean','max']
result = grouped['tip_pct','total_bill'].agg(functions)         #对两列都应用functions
result['tip_pct']
 
ftuples = [('DDD','mean'),('AAA',np.var)]
print (grouped['tip_pct','total_bill'].agg(ftuples))
 
#如果想对不同的列应用不同的函数，具体的办法是向agg传入一个从列映射到函数的字典
print (grouped.agg({'tip':np.max,'size':sum}))                  #sum这样的函数可以加引号或者不加
print (grouped.agg({'tip':['min','max','mean','std'],'size':sum}))
 
-------以‘无索引’的方式返回聚合数据
tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
print tips.head()
print tips.groupby(['sex','smoker'],as_index = False).mean() #这里的形式可能有时候更好用
 
-------分组级运算和转换
#下面为DataFrame添加一个用于存放各索引分组平均值的列。一个办法是先聚合在合并：
df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
k1_means = df.groupby('key1').mean().add_prefix('mean_')
#下面用左边的key1作为连接键，right_index是将右边的行索引作为连接键
print pd.merge(df,k1_means,left_on = 'key1',right_index = True)
#上面的方法虽然也行，但是不灵活。可以看作利用mean函数对数据的两列进行转换。
people = DataFrame(np.random.randn(5,5),columns = ['a','b','c','d','e'],
index = ['Joe','Steve','Wes','Jim','Travis'])
print people
key = ['one','two','one','two','one']
print people.groupby(key).mean()
#看下面神奇的事情
print people.groupby(key).transform(np.mean),'\n'
#不难看出，transform会将一个函数应用到各个分组并将结果放置到适当的位置，
#如果各分组产生的是一个标量值，则改值就会被广播出去
#下面的例子很说明问题，很灵活
def demean(arr):
    return arr - arr.mean()
demeaned = people.groupby(key).transform(demean)
print demeaned,'\n'
#下面检查一下demeaned各组均值是否为0
print demeaned.groupby(key).mean()
 
-------apply:一般性的“拆分-应用-合并”
tips = pd.read_csv('E:\\tips.csv')                           #增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
#print tips.head()
#下面找出指定列的最大的几个值，然后将所在行选出来
def top(df,n = 5,column = 'tip_pct'):
    return df.sort_index(by = column)[-n:]
print top(tips,n = 6)
#如果对smoker分组并用该函数调用apply
print tips.groupby('smoker').apply(top),'\n'
#上面实际上是在各个片段上调用了top，然后用pd.concat进行了连接，并以分组名称进行了标记，于是就形成了层次化索引
#当然可以向top函数传入参数
print tips.groupby(['smoker','day']).apply(top,n = 1,column = 'total_bill')
#需要说明的是：apply很强大，需要发挥想象力，它只需返回一个pandas对象或者标量值即可
#之前曾经这么做过：
result = tips.groupby('smoker')['tip_pct'].describe()
print result,'\n'
print result.unstack('smoker'),'\n'
#下面的方式,效果一样
f = lambda x : x.describe()
print tips.groupby('smoker')['tip_pct'].apply(f),'\n'
#对所有列都行
print tips.groupby('smoker').apply(f),'\n'
#看的出，上面自动生成了层次化索引，可以将分组键去掉
print tips.groupby('smoker',group_keys = False).apply(top),'\n'
#下面看得出，重新设置索引会去掉原来所有索引，并重置索引
print tips.groupby('smoker').apply(top).reset_index(drop = True),'\n'
#下面看的出来，as_index在这里并不管用
print tips.groupby('smoker',as_index = False).apply(top),'\n'
#下面看的出来，as_index在这里并不管用
print tips.groupby(['sex','smoker'],as_index = False).apply(top),'\n'
 
-------分位数和桶分析
frame=DataFrame({'data1':np.random.randn(1000),'data2':np.random.randn(1000)})
frame.head()
面向列的多函数应用#切分成4份(等距切割，非等量)
factor=pd.cut(frame.data1,4)
 
def get_stats(group):
return('min':group.min(),'max':group.max(),'count':group.count())
grouped=frame.data2.groupby(factor)
grouped.apply(get_stats).unstack()
 
#利用qcut进行等量切割
grouping=pd.qcut(frame.data1,10,labels=False)
print(grouping)
grouped=frame.data2.groupby(grouping)
print(grouped.apply(get_stats).unstack())
 
 
https://www.cnblogs.com/batteryhp/p/5049644.html
----------------------------------示例部分
-------3.1用特定于分组的值填充缺失值
s = Series(np.random.randn(6))
s[::2] = np.nan
s.fillna(s.mean())       --->缺失值以均值填充
#假如需要对不同的分组填充不同的值。只需要groupby然后应用fillna即可。
states = ['Ohio','New York','Vermont','Florida','Oregon','Nevada','California','Idaho']
group_key = ['East'] * 4 + ['West'] * 4
data = Series(np.random.randn(8),index = states)
data[['Vermont','Nevada','Idaho']] = np.nan
data.groupby(group_key).mean()
#lambda函数方法填充
fill_mean = lambda g:g.fillna(g.mean())
data.groupby(group_key).apply(fill_mean)
#1定义填充值
fill_values = {'East':0.5,'West':0.4}
fill_func = lambda g:g.fillna(fill_values[g.name])
data.groupby(group_key).apply(fill_func)
 
-------3.2随机采样和排列
假如想从一个大数据集中抽样完成蒙特卡洛模拟或其他工作。
“抽取”的方式有很多，但是效率是不一样的。一个办法是，
选取np.random.permutation(N)的前K个元素。下面是个更有趣的例子：
#红桃（Hearts）、黑桃（Spades)、梅花（Clubs）、方片（Diamonds）
suits = ['H','S','C','D']
card_val = (range(1,11) + [10] * 3) * 4
#print(card_val)
base_names = ['A'] + range(2,11) + ['J','K','Q']
cards = []
for suit in ['H','S','C','D']:
    cards.extend(str(num) + suit for num in base_names)
print(cards)
deck = Series(card_val,index = cards)
print (deck[:13])
#从牌中抽取5张，注意抽取方式,是一种随机选取5个的方式，即先选出一个排列，再从中拿出5个
def draw(deck,n = 5):
    return deck.take(np.random.permutation(len(deck))[:n])
print (draw(deck))
#假如想从每种花色中随机抽取两张。先分组，再对每个组应用draw函数进行抽取
get_suit = lambda card:card[-1]
print(deck.groupby(get_suit).apply(draw,2))
#另一种方法
print (deck.groupby(get_suit,group_keys = False).apply(draw,2))
 
-------3.3分组加权平均数和相关系数
df = DataFrame({'category':list('aaaabbbb'),
'data':np.random.randn(8),'weights':np.random.randn(8)})
#下面以category分组并计算加权平均
grouped=df.groupby('category')
get_wavg=lambda g:np.average(g['data'],weights=g['weights'])
grouped.apply(get_wavg)
close_px = pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch11/stock_px.csv',
parse_dates = True,index_col = 0)
#下面做一个比较有趣的任务：计算一个由日收益率（通过百分比计算）与SPX之间的年度相关系数
#组成的DataFrame,下面是一个实现办法,下面的pct_change是计算每列下一个数值相对于上一个值的百分比变化，所以，第一个肯定为NaN
rets = close_px.pct_change().dropna()
#print rets[-4:]
spx_corr = lambda x:x.corrwith(x['SPX'])
#注意下面隐式的函数，作者好高明
by_year = rets.groupby(lambda x:x.year)
#对每一小块的所有列和SPX列计算相关系数
print by_year.apply(spx_corr),'\n'
#当然，还可以计算列与列之间的相关系数
print by_year.apply(lambda g:g['AAPL'].corr(g['MSFT']))
 
-------3.4面向分组的线性回归
import statsmodels.api as sm
def regress(data,yvar,xvars):
    Y = data[yvar]
    X = data[xvars]
    X['intercept'] = 1
    result = sm.OLS(Y,X).fit()
    return result.params
print by_year.apply(regress,'AAPL',['SPX'])
 
-------4 透视表和交叉表 pivot_table和cross table
---pivot_table
tips=pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch08/tip.csv')
tips['tip_pct'] = tips['tip'] / tips['total_bill']
tips.pivot_table(index = ['sex','smoker'])
#对tip_pct和size根据index=sex和day 列为smoke or not 做数透视表
tips.pivot_table(['tip_pct','size'],index = ['sex','day'],columns = 'smoker')
#可以添加选项  margins = True添加分项小计。这将会添加All行和列,这里的all行或者列将不考虑差别，算整体的值
tips.pivot_table(['tip_pct','size'],index= ['sex','day'],columns = 'smoker',margins = True)
#对透视表 应用函数aggfunc
tips.pivot_table('tip_pct',index = ['sex','smoker'],columns = 'day',aggfunc = len,margins = True)
tips.pivot_table('size',index = ['time','sex','smoker'],columns = 'day',aggfunc = 'sum',fill_value = 0)
 
pivot_table参数
参数名             说明
values            待聚合的列的名称。默认聚合所有数值
index             index键
columns           列键
aggfunc           应用函数或函数列表,默认为'mean' 可以是对groupby有效的函数
fill_value        用于替换结果表中的缺失值
margins           添加行/列小计和总计,默认为False
 
---交叉表：crosstab
data = DataFrame({'Sample':range(1,11,1),'Gender':['F','M','F','M','M','M','F','F','M','F'],'Handedness':['R','L','R','R','L','R','R','L','R','R']})
pd.crosstab(data.Gender,data.Handedness,margins = True) #第1(|),2(-)个参数可以是列表或数组
pd.crosstab([tips.time,tips.day],tips.smoker,margins = True)
 
 
-------5.2012联邦选举委员会数据库
fec = pd.read_csv('E:\\P00000001-ALL.csv')
print fec,'\n'
print fec.ix[123456],'\n'
#下面介绍几种不同的分析方法
#通过unique，你可以获取全部的候选人名单
unique_cands = fec.cand_nm.unique()
print unique_cands,'\n'
#下面将候选人和党派对应起来,额，写了半天，奥巴马是Democrat（民主党），其他人都是共和党……
parties = {'Bachmann, Michelle':'Republican',
'Cain, Herman':'Republican',
'Gingrich, Newt':'Republican',
'Huntsman, Jon':'Republican',
'Johnson, Gary Earl':'Republican',
'McCotter, Thaddeus G':'Republican',
'Obama, Barack':'Democrat',
'Paul, Ron':'Republican',
'Pawlenty, Timothy':'Republican',
'Perry, Rick':'Republican',
"Roemer, Charles E. 'Buddy' III":'Republican',
'Romney, Mitt':'Republican',
'Santorum, Rick':'Republican'}
#为其添加新列
fec['party'] = fec.cand_nm.map(parties)
print fec['party'].value_counts(),'\n'
#注意，这份数据既包括赞助也包括退款
print (fec.contb_receipt_amt > 0).value_counts(),'\n'
#为了简便，这里将只研究正出资额的部分
fec = fec[fec.contb_receipt_amt > 0]
#专门准备两个子集盛放奥巴马和Mitt Romney
fec_mrbo = fec[fec.cand_nm.isin(['Obama, Barack','Romney, Mitt'])]
#根据职业和雇主统计赞助信息，例如律师倾向于赞助民主党，企业主倾向于自主共和党
#下面看一下职业
print fec.contbr_occupation.value_counts()[:10],'\n'
#下面将这些职业进行一些处理（将一个职业信息映射到另一个）
occ_mapping = {
    'INFORMATION REQUESTED PER BEST EFFORTS':'NOT PROVIDED',
    'INFORMATION REQUESTED':'NOT PROVIDED',
    'INFORMATION REQUESTED (BEST EFFORTS)':'NOT PROVIDED',
    'C.E.O':'CEO'
}
#下面用了一个dict.get，下面的get第一个x是dict的键，映射到返回对应的key，第二个是没有映射到返回的内容，如果没有提供映射的话，返回x
f = lambda x:occ_mapping.get(x,x)
fec.contbr_occupation = fec.contbr_occupation.map(f)
#对雇主的信息也这样处理一下
emp_mapping = {
    'INFORMATION REQUESTED PER BEST EFFORTS':'NOT PROVIDED',
    'INFORMATION REQUESTED':'NOT PROVIDED',
    'SELF':'SELF-EMPLOYED',
    'SELF EMPLOYED':'SELF-EMPLOYED'
}
f = lambda x:emp_mapping.get(x,x)
fec.contbr_employer = fec.contbr_employer.map(f)
#下面可以通过pivot_table根据党派和职业对数据进行聚合，然后过滤掉出资总额不足200万美元的数据
by_occupation = fec.pivot_table('contb_receipt_amt',rows = 'contbr_occupation',cols = 'party',aggfunc = sum)
print by_occupation.head(),'\n'  #这个数据一定要看一下
over_2mm = by_occupation[by_occupation.sum(1) > 2000000]
print over_2mm
over_2mm.plot(kind = 'barh')
plt.show()
#你可能还想了解一下对OBAMA和ROMNEY总出资额最高的职业和企业，想法是先分组，然后再选取
def get_top_amounts(group,key,n = 5):
    totals = group.groupby(key)['contb_receipt_amt'].sum()
    return totals.order(ascending = False)[:n]  #作者书上写错了
grouped = fec_mrbo.groupby('cand_nm')
#下面的语句是说，grouped对象可以被进一步groupby
print grouped.apply(get_top_amounts,'contbr_occupation',n = 7),'\n'
print fec_mrbo.groupby(['cand_nm','contbr_occupation'])['contb_receipt_amt'].sum(),'\n' #不知道这里为啥不对……，为什么跟前面的语句结果不一样？……
#print fec_mrbo.pivot_table('contb_receipt_amt',rows = ['cand_nm','contbr_occupation'],aggfunc = 'sum')
print grouped.apply(get_top_amounts,'contbr_employer',n = 10)
 
---对出资额分组
#部分代码
bins = np.array([0,1,10,100,1000,10000,100000,1000000,10000000])
labels = pd.cut(fec_mrbo.contb_receipt_amt,bins)
print labels,'\n'
#然后根据候选人姓名以及面元标签对数据进行分组
grouped = fec_mrbo.groupby(['cand_nm',labels])
print grouped.size().unstack(0),'\n'  #可以看出两个候选人不同面元捐款的数量
#还可以对出资额求和并在面元内规格化，以便图形化显示两位候选人各种赞助的比例
bucket_sums = grouped.contb_receipt_amt.sum().unstack(0)
print bucket_sums,'\n'
normed_sums = bucket_sums.div(bucket_sums.sum(axis = 1),axis = 0)
print normed_sums,'\n'
#排除最大的两个面元并作图：
normed_sums[:-2].plot(kind = 'barh',stacked = True)
plt.show()
 
-------------------------------------------------CP10 时间序列------------------------------------------------
https://www.cnblogs.com/batteryhp/p/5055149.html
http://www.cnblogs.com/batteryhp/p/5058400.html
https://www.cnblogs.com/batteryhp/p/5059670.html
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import datetime as dt
from datetime import datetime
from dateutil.parser import parse
from pandas import Series,DataFrame
import time
from pandas.tseries.offsets import Hour,Minute,Day,MonthEnd
import pytz
 
-------1、日期和时间数据类型及工具
now = datetime.now()
now,now.year,now.month,now.day,now.microsecond
#datetime格式可以相相减
delta = datetime(2011,1,7) - datetime(2008,6,24,8,15)
delta
#把注意下面是days And seconds
dt.timedelta(926,56700)
delta.days
delta.seconds
 
##datetime模块中的数据类型
date                                    以公历形式存储日历日期(年月日)
time                                    将时间存储为时，分，秒，毫秒
datetime                                存储日期和时间
timedelta                               表示两个datetime值之间的差
 
#字符串转时间格式(strftime方法)
str(datetime(2011,1,3))
stamp.strftime('%Y-%m-%d')
 
datestrs = ['7/6/2011','8/6/2011']
[datetime.strptime(x,'%m/%d/%Y') for x in datestrs]     #注意这是datetime函数的函数，不是模块的函数
 
#dateutil包的parser.parser方式
parse('2011/01/03')
parse('Jan 31,1997 10:45 PM')
 
#国际通用格式中，日出现在月的前面，传入dayfirst = True即可
parse('6/12/2011',dayfirst = True)
 
##datetime格式定义
%Y                                    4位数年
%y                                    2位数年
%m                                    2位数月
%d                                    2位数日
%H                                    时（24）[00,23]
%I                                    时（12）[01,12]
%M                                    2位数的分[00,59]
%S                                    秒[00.61]
%w                                    用整数表示的星期几[0(sunday)，6]
%U                                    每年的第几周[00,53] 星期天为每周第一天，每年第一个新七天之前为0周
%W                                    每年的第几周[00,53] 星期一为每周第一天，每年第一个新七天之前为0周
%z                                    以+HHMM或-HHMM表示的UTC时区偏移量
%F                                    %Y-%m-%d简写形式,例2018-8-18
%D                                    %m/%d/%y简写形式,例18/08/18
 
##特定于当前环境的日期格式
%a                                    星期几的简写
%A                                    星期几的全称
%b                                    月份的简写
%B                                    月份的全称
%c                                    完整的日期和时间,例如'Tue 01 May 2018 10:18:18 AM'
%p                                    不同环境中的AM和PM
%x                                    适合于当前环境的日期格式，例如 in USA 'may 1,2012'会产生'05/0`/2012'
%X                                    适合于当前环境的时间格式，例如'08:28:18 PM'
 
-------2、时间序列基础
dates = [datetime(2011,1,2),datetime(2011,1,5),datetime(2011,1,7),
datetime(2011,1,8),datetime(2011,1,10),datetime(2011,1,12)]
#print dates
ts = Series(np.random.randn(6),index = dates)
type(ts)
ts.index
ts + ts[::2]
ts.index.dtype
stamp = ts.index[0]
stamp
 
#索引、选取、子集构造
ts[ts.index[2]]
#还有更方便的用法，传入可以被解释为日期的字符串
ts['1/10/2011']
ts['20110110']
#对于较长的时间序列，只需传入“年”或“年月”即可轻松选取数据切片
long_ts = Series(np.random.randn(1000),
index = pd.date_range('1/1/2000',periods = 1000))
long_ts
long_ts['2001']
long_ts['2001-05']
ts[datetime(2011,1,7):]      #对时间段切片 选择2011年1月7日后的数据
ts['1/6/2011':'1/11/2011']
 
print('This is time and localtime')
print("time.time(): %f " %  time.time())
print(time.localtime( time.time() ))
print( time.asctime( time.localtime(time.time()) ))
ltime=time.localtime(int(time.time()))   #time.time()不能直接运用strftime进行转换
time.strftime("%Y-%m-%d %H:%M:%S", ltime)
#time asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"
print 'over','\n'
 
#还有一个等价方法截取两个日期之间的TimeSeries.
ts.truncate(after = '1/9/2011')
 
#上面这些对DataFrame也有效
dates = pd.date_range('1/1/2000',periods = 100,freq = 'W-WED') #这里的freq是按照星期进行增加
long_df = DataFrame(np.random.randn(100,4),index = dates,columns = ['Colorado','Texas','New York','Ohio'])
long_df.ix['2001-05']
 
##带有重复索引的时间序列
dates = pd.DatetimeIndex(['1/1/2000','1/2/2000','1/2/2000','1/2/2000','1/3/2000'])
dup_ts = Series(np.arange(5),index = dates)
dup_ts.index.is_unique   --->False
grouped=dup_ts.groupby(level=0)     ---> 对唯一时间戳进行聚合groupby，LEVEL=0
grouped.mean()
grouped.count()
 
 
-------3、日期的范围、频率以及移动
dates = [datetime(2011,1,2),datetime(2011,1,5),datetime(2011,1,7),
datetime(2011,1,8),datetime(2011,1,10),datetime(2011,1,12)]
ts = Series(np.random.randn(6),index = dates)
#下面进行重采样，得到具有固定时间频率（每天）的时间序列，当让这样的话就会产生缺失值
print ts.resample('D')
 
#生成日期范围(DATE_RANGE)
index = pd.date_range('4/1/2015','6/1/2015')          --->产生一个date_range
pd.date_range('1/1/2016',periods = 31)                --->产生一个从2016-1-1开始 周期为31天的时间数据
pd.date_range('12/18/2015','1/1/2016',freq = 'BM')    --->BM:bussiness end of month,传入一个时间区间并以bm形式
 
#date_range默认保留起始和结束时间戳信息
pd.date_range('5/2/2015 12:12:12',periods = 5)
#有时，虽然起始和结束带有时间信息，但是可以用normalize = True把它们吧变为00:00:00
pd.date_range('5/2/2015 12:12:12',periods = 5,normalize = True)
 
 
#频率和日期偏移量
from pandas.tseries.offsets import Hour,Minute
#pandas中的频率是由一个基础频率和一个乘数组成的。基础的频率由字符串表示，比如‘M’表示月，‘H’表示小时
#对于每个基础频率，都有一个被称为日期偏移量（date offset）的对象与之对应。
hour = Hour()
print hour #感觉这个形式比较霸气
#传入整数可以自定义偏移量倍数
four_hours = Hour(4)
print four_hours
#一般而言，并不需要显示创建偏移量，只需创建时间序列时传入'H'或者'4h'即可
print pd.date_range('1/1/2016','1/2/2016',freq = '4h'),'\n'
#偏移量可以拼接
print Hour(1) + Minute(30)
#传入频率字符串（'2h30min'）,这种字符串可以被高效地解析为等效的表达式
print pd.date_range('1/1/2016',periods = 10,freq = '1h30min'),'\n'
#有些频率所描述的时间点并不是均匀分隔的。例如'M'和'BM'就取决于每月的天数，对于后者，还要考虑月末是不是周末，将这些成为锚点偏移量（anchored offset）
#WOM(Week Of Month)日期是一个非常常用的频率，以WOM开头，能产生诸如“每月第三个星期五”之类的信息
rng = pd.date_range('1/1/2016','9/1/2016',freq = 'WOM-3FRI')
 
##时间序列的基础频率表(freq参数)
D                        Day                       每日历日
B                        BusinessDay               每工作日
H                        Hour                      每小时
T/min                    Minute                    每分
S                        Second                    每秒
L/ms                     Milli                     每毫秒
U                        Micro                     每微秒
M                        MonthEnd                  每月最后一个日历日
BM                       BusinessMonthEnd          每月最后一个日历日    
MS                       MonthBegin                每月第一个日历日
BMS                      BusinessMonthBegin        每月第一个工作日                      
W-MON/W-TUE...           Week                      从指定的星期几(mon,tues,wed,thu,fri,sat,sun)开始算起,每周         
WOM-1MON/WOM-2MON...     WeekOfMonth               产生每月第一二三或四周的星期几。例如，WOM-3FRI表示每月第3个星期五               
Q-JAN/Q-FEB...           QuarterEnd                对于指定月份(JAN,FEB,MAR,...DEC)结束的年度,每季度最后一个月的最后一个日历日         
BQ-JAN/BQ-FEB...         BusinessQuarterEnd        对于以指定月份结束的年度,每季度最后一月的最后一个工作日
QS-JAN/QS-FEB...         QuarterBegin              对于指定月份结束的年度,每季度最后一月的第一个日历日
BQS-JAN/BQS-FEB...       BusinessQuarterBegin      对于指定月份结束的年度,每季度最后一月的第一个工作日
A-JAN/A-FEB              YearEnd                   每年指定月份(JAN,FEB...DEC)的最后一个日历日
BA-JAN/BA-FEB...         BusinessYearEnd           每年指定月份的最后一个工作日
AS-JAN/AS-FEB...         YearBegin                 每年指定月份的第一日历日
BAS-JAN/BAS-FEB...       BusinessYearBegin         每年指定月份的第一个工作日
 
 
#移动（超前和滞后）数据（移动数据或时间戳）
ts = Series(np.random.randn(4),index = pd.date_range('1/1/2016',periods = 4,freq = 'M'))
ts.shift(2)/ts.shift(-2)
ts / ts.shift(1) - 1          #计算环比
ts.shift(2,freq = 'M')        #时间戳移动，而数据不动
ts.shift(3,freq = 'D'),'\n'  #时间的移动不是上下移动，而是将时间列的每个值进行移动
ts.shift(1,freq = '3D')
ts.shift(1,freq = '90T')
 
#通过偏移量对日期进行位移
now = datetime(2018,11,18)
type(now)
now + Day(3)
#如果加的是锚点偏移量，第一次增量会将原日期向前滚动到符合频率规则的下一个日期
#如果本来就是锚点，那么下一个就是下一个锚点
now + MonthEnd()   #本月底
now + MonthEnd(2)  #下月底
#通过锚点偏移量的rollforward和rollback方法，可显示地将日期向前或向后“滚动”
offset = MonthEnd()
offset.rollforward(now)
offset.rollback(now)
#日期偏移量还有一个巧妙的用法，即结合groupby使用这两个“滚动”方法
ts = Series(np.random.randn(20),index = pd.date_range('1/15/2000',periods = 20,freq = '4d'))
ts
#注意下面的方式，很隐晦
ts.groupby(offset.rollforward).mean()
#当然，更简单快速的方式是使用resample
ts.resample('M',how = 'mean')
 
-------时区转换和处理
import pytz
pytz.common_timezones[-5:]             #从pytz内获取时区对象
tz = pytz.timezone('US/Eastern')       #获取US西部时间区
 
-------本地化和转换
rng = pd.date_range('3/9/2012 9:30',periods = 6,freq = 'D')
ts = Series(np.random.randn(len(rng)),index = rng)
pd.date_range('3/9/2012',periods = 10,freq = 'D',tz = 'UTC')
ts_utc = ts.tz_localize('US/Pacific')    #对时区进行localize
ts_utc.tz_convert('US/Eastern')          #再对localized的时区进行转换
 
-------操作时区意识型（time zone-aware）Timestamp对象
stamp = pd.Timestamp('2011-03-12 04:00')
type(stamp)
stamp_utc = stamp.tz_localize('UTC')
stamp_utc.tz_convert('US/Eastern')
stamp_moscow = pd.Timestamp('2011-03-12 04:00',tz = 'Europe/Moscow')
stamp_utc.value                            #UTC值 自1970年1月1日起的纳秒数
stamp_utc.tz_convert('US/Eastern').value   #转换过程中这个值不会变 
 
-------不同时区之间的运算
rng = pd.date_range('3/7/2012',periods = 10,freq = 'B')
ts = Series(np.random.randn(len(rng)),index = rng)
ts1 = ts[:7].tz_localize('Europe/London')
ts2 = ts1[2:].tz_convert('Europe/Moscow')
result = ts1 + ts2                        #匹配相应的时区进行计算,
 
-------5、时期及其算数运算
p = pd.Period('2016',freq = 'A-DEC')
p + 5
rng = pd.Period('2015',freq = 'A-DEC') - p   ---> -1
#注意下面的形式已经不是书上的形式，而是float类型，但是做索引时，还是日期形式
type(rng)
Series(np.random.randn(6),index = rng) 
values = ['2001Q3','2002Q2','2003Q1']
index = pd.PeriodIndex(values,freq = 'Q-DEC')
 
-------时期的频率转换(asfreq)
p = pd.Period('2007',freq = 'A-DEC')
p
p.asfreq('M',how = 'start')
p.asfreq('M',how = 'end')
#高频率转换为低频率时，超时期是由子时期所属位置决定的,例如在A-JUN频率中，月份“2007年8月”实际上属于“2008年”
p = pd.Period('2007-08','M')
p.asfreq('A-JUN')
rng = pd.period_range('2006','2009',freq = 'A-DEC')
ts = Series(np.random.randn(len(rng)),index = rng)
ts.asfreq('M',how = 'start')   --->转换为年初的Month
ts.asfreq('B',how = 'end')     --->转换为年末的BusinessDay
pts = ts.to_period()
#由于时期指的是非重叠时间区间，因此对于给定的频率，一个时间戳只能属于一个时期。
#新PeriodIndex的频率默认是从时间戳推断而来的，当然可以自己指定频率，当然会有重复时期存在
rng = pd.date_range('1/29/2000',periods = 6,freq = 'D')
ts2 = Series(np.random.randn(6),index = rng)
ts2
ts2.to_period('M')
#要想转换为时间戳，使用to_timestamp即可
pts.to_timestamp(how = 'end')
 
-------通过数组创建PeriodIndex 
data = pd.read_csv('E:\\macrodata.csv')
data.year
data.quarter
index = pd.PeriodIndex(year = data.year,quarter = data.quarter,freq = 'Q-DEC')
  #index是以整数数组的形式存储的，当显示某一个是才会有年份-季度的展示
data.index = index
  #下面的结果证明，infl的index已经变为了年份-季度形式
data.infl
 
-------6、重采样及频率转换 (resample)
rng = pd.date_range('1/1/2000',periods = 100,freq = 'D')
ts = Series(np.random.randn(100),index = rng)
ts.resample('M',how = 'mean')                      --->按照monthend求均值的resample
ts.resample('M',how = 'mean',kind = 'period')      --->按照月周期求mean
 
#resample参数
loffset=None                         面元标签的时间校正,例:'-1s'/Second(-1)用于将聚合标签调早一秒
limit=None                           在前向或后向填充时,允许填充最大期数
kind=None                            聚合到时期('period')或时间戳('timestamp'),默认聚合到时间序列的索引类型
convention=None                      当重采样时期时,将低频率转换到高频率多采用的约定('start'或'end'),默认为'end'
freq                                 表示重采样频率的字符串或DataOffset,例'M','5min'或Second(15)
how='mean'                           用于产生聚合值得函数名或数组函数'mean','ohlc','np.max'。默认为mean,
                                     其他常用的值有first last median ohlc max min
axis=0                               重采样的轴,默认为0
fill_method=None                     升采样时如何插值,比如ffill/bfill,默认不插值
closed='right'                       在降采样中,各时间段的哪一端时闭合的默认'right'
label='right'                        在降采样中,如何设置聚合值得标签,right或left(面元的右/左边界)
                                     例,9:30-9:35 之间的者五分钟会被标记为9:30 or 9:35 默认为'right' (本例中就是9:35)
#降采样
将数据的频率降低称为降采样，也就是将数据进行聚合。
一个数据点只能属于一个聚合时间段，所有时间段的并集组成整个时间帧。
rng = pd.date_range('1/1/2000',periods = 12,freq = 'T')
ts = Series(range(0,12),index = rng)             --->生成一分钟线
ts.resample('5min',how = 'sum')                  --->聚合到5min线
  #传入的频率将会以“5min”的增量定义面元。默认情况下，面元的有边界是包含右边届的，即00:00到00:05是包含00:05的
  #传入closed = 'left'会让左边的区间闭合
print ts.resample('5min',how = 'sum',closed = 'left')
  #最终的时间序列默认是用右侧的边界标记，但是传入label = 'left'可以转换为左边标记
ts.resample('5min',how = 'sum',closed = 'left',label = 'left')
ts.resample('5min',how = 'sum',closed = 'left',loffset = '-1s')     #label减去1s
 
#OHLC重采样
rng = pd.date_range('1/1/2000',periods = 12,freq = 'T')
ts = Series(np.random.randn(12),index = rng)
ts
ts.resample('5min',how = 'ohlc')
按照5min进行聚类 结果呈现ohlc(open,high,low,close)
 
#通过groupby进行重采样
rng = pd.date_range('1/1/2000',periods = 100,freq = 'D')
ts = Series(np.arange(100),index = rng)
ts.groupby(lambda x:x.month).mean()  #作真是越写越省事了……
ts.groupby(lambda x:x.weekday).mean()
 
#升采样和差值
frame = DataFrame(np.random.randn(2,4),index = pd.date_range('1/1/2000',periods = 2,freq = 'W-WED'),
columns = ['Colorado','Texas','New York','Ohio'])
  #将其重采样到日频率，默认会引入缺省值
df_daily = frame.resample('D')
  #可以跟fillna和reindex一样，将上面的数值用resampling进行填充
frame.resample('D',fill_method = 'ffill')
  #同样，这里可以只填充指定的时期数（目的是限制前面的观测值的持续使用距离）
frame.resample('D',fill_method = 'ffill',limit = 2)
  #注意，新的日期索引完全没必要跟旧的相交,注意这个例子展现了数据日期可以延长
frame.resample('W-THU',fill_method = 'ffill')
 
#通过日期进行重采样
frame = DataFrame(np.random.randn(24,4),
index = pd.period_range('1-2000','12-2001',freq = 'M'),
columns = ['Colorado','Texas','New York','Ohio'])
annual_frame = frame.resample('A-DEC',how = 'mean')
 
 #升采样要稍微麻烦些，因为你必须决定在新的频率中各区间的哪端用于放置原来的值，就像asfreq方法一样，convention默认为'end',可设置为'start'
 #Q-DEC：季度型（每年以12月结束）
annual_frame.resample('Q-DEC',fill_method = 'ffill')
annual_frame.resample('Q-DEC',fill_method = 'ffill',convention = 'start'),'\n'
 #由于时期指的是时间区间，所以升采样和降采样的规则就比较严格
 #在降采样中，目标频率必须是原频率的子时期
 #在升采样中，目标频率必须是原频率的超时期
 #如果不满足这些条件，就会引发异常，主要影响的是按季、年、周计算的频率。
 #例如，由Q-MAR定义的时间区间只能升采样为A-MAR、A-JUN等
annual_frame.resample('Q-MAR',fill_method = 'ffill')
 
 
------7、时间序列绘图
#下面两个参数，一个是解析日期形式，一个是将第一列作为行名
close_px_all = pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch11/stock_px.csv',
parse_dates = True,index_col = 0)
close_px_all.head()
close_px = close_px_all[['AAPL','MSFT','XOM']]
close_px = close_px.resample('B',fill_method = 'ffill')
close_px.head()
 #注意下面的索引方式即可
close_px['AAPL'].plot()
close_px.ix['2009'].plot()
close_px['AAPL'].ix['01-2011':'03-2011'].plot()
 #季度型频率的数据会用季度标记进行格式化，这种事情手工的话会很费力……（真是有道理……）
appl_q = close_px['AAPL'].resample('Q-DEC',fill_method = 'ffill')
appl_q.ix['2009':].plot()
 #作者说交互方式右键按住日期会动态展开或收缩，实际自己做，没效果……
plt.show()
 
-------8、移动窗口函数 
  #在移动窗口（可以带有指数衰减权数）上计算的各种统计函数也是一类常见于时间序列的数组变换。
作者将其称为移动窗口函数（moving window function），其中还包括那些窗口不定长的函数（如指数加权移动平均）。
跟其他统计函数一样，移动窗口函数也会自动排除缺失值。这样的函数通常需要指定一些数量的非NA观测值。
  #rolling_mean是其中最简单的一个。它接受一个TimeSeries或DataFrame以及一个window（表示期数）
close_px_all = pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch11/stock_px.csv',parse_dates = True,index_col = 0)
close_px_all.head()
close_px = close_px_all[['AAPL','MSFT','XOM']]
close_px = close_px.resample('B',fill_method = 'ffill')
close_px.AAPL.plot()
pd.rolling_mean(close_px.AAPL,250).plot()
plt.show()
 
close_px.AAPL.plot()
appl_std250 = pd.rolling_std(close_px.AAPL,250,min_periods = 10)
appl_std250[:15]
appl_std250.plot()
plt.show()
 
  #扩展窗口平均（expanding window mean）
#通过rolling_mean定义扩展平均
expanding_mean = lambda x:rolling_mean(x,len(x),min_periods = 1)
#对DataFrame调用rolling_mean（以及其他类似函数）会将转换应用到所有列上
#下面的logy是将纵坐标显示为科学计数法，暂时搞不懂怎么变换的
mean_60 = pd.rolling_mean(close_px,60).plot()
mean_60 = pd.rolling_mean(close_px,60).plot(logy = True)
 
#print mean_60[(len(mean_60) - 20):len(mean_60)]
plt.show()
'''
ts = pd.Series(range(10), index=pd.date_range('1/1/2000', periods=10))
#ts = np.exp(ts.cumsum())
print ts
print np.log(ts)
ts.plot(logy=True)
plt.show()
'''
移动窗口和指数加权函数
rolling_count                                 返回各窗口非NA观测值得数量
rolling_sum                                   移动窗口的和
rolling_mean                                  移动窗口的平均值
rolling_median                                移动窗口的中位数
rolling_var,rolling_std                       移动窗口的方差和标准差,分母为N-1
rolling_skew,rolling_kurt                     移动窗口的偏度(三阶距)和峰度
rolling_min,rolling_max                       移动窗口的最小最大值
rolling_quantile                              移动窗口的百分位数/样本分位数位置的值
rolling_corr,rolling_cov                      移动窗口的相关系数和协方差
rolling_apply                                 对移动窗口应用普通数组函数
ewmva                                         指数加权移动平均
ewmvar,ewmstd                                 指数加权移动方差和标准差
ewmcorr,ewmcov                                指数加权移动相关系数和协方差
 
#指数加权函数
另一种使用固定大小窗口及相等权数观测值的方法是，
定义一个衰减因子（decay factor）常量，
以便使近期的观测值拥有更大的权数。衰减因子的定义方式有很多，
比较流行的是使用时间间隔（span），
它可以使结果兼容于窗口大小等于时间间隔的简单移动窗口函数。
 
fig,axes = plt.subplots(nrows = 2,ncols = 1,sharex = True,sharey = True,figsize = (12,7))
aapl_px = close_px.AAPL['2005':'2009']
ma60 = pd.rolling_mean(aapl_px,60,min_periods = 50)
ewma60 = pd.ewma(aapl_px,span = 60)
 
aapl_px.plot(style = 'k-',ax = axes[0])
ma60.plot(style = 'k--',ax = axes[0])
aapl_px.plot(style = 'k-',ax = axes[1])
ewma60.plot(style = 'k--',ax = axes[1])
axes[0].set_title('Simple MA')
axes[1].set_title('Exponentially-weighted MA')
plt.show()
 
#二元移动窗口函数
有些统计运算（如相关系数和协方差）需要在两个时间序列上执行。
比如，金融分析师常常对某只股票对某个参数（如标普500指数）的相关系数感兴趣。
我们可以通过计算百分比变化并使用rolling_corr的方式得到该结果。
 
#rolling_mean是其中最简单的一个。它接受一个TimeSeries或DataFrame以及一个window（表示期数） 
close_px_all = pd.read_csv('E:/work/qbao/PY-W-new/pydata-book-master/ch11/stock_px.csv',
parse_dates = True,index_col = 0)
close_px_all.head(),'\n'
close_px = close_px_all[['AAPL','MSFT','XOM']]
 
spx_px = close_px_all['SPX']
print spx_px
#下面是将spx_px数据后移一位，减1是将数据减1，当然后面的是先除，再减1
#print spx_px.shift(1) - 1
spx_rets = spx_px / spx_px.shift(1) - 1
#看一下，下面的函数是跟上面的一样，作者是为了展示函数才这么写的
#spx_rets_pct_change = spx_px.pct_change()
#print spx_rets_pct_change[:10]
spx_rets[:10],'\n'
returns = close_px.pct_change()
returns[:10]
corr = pd.rolling_corr(returns.AAPL,spx_rets,125,min_periods = 100)
corr.plot()
plt.show()
 
#用户自定义的移动窗口函数
rolling_apply函数使你能够在移动窗口上应用自己设计的数组函数。
唯一的要求就是：该函数要能从数组的各个片段中产生单个值。
比如，当用rolling_quantile计算样本分位数时,
可能对样本中特定值的百分等级感兴趣。
from scipy.stats import percentileofscore
#rolling_mean是其中最简单的一个。它接受一个TimeSeries或DataFrame以及一个window（表示期数） 
close_px_all = pd.read_csv('E:\\stock_px.csv',parse_dates = True,index_col = 0)
close_px = close_px_all[['AAPL','MSFT','XOM']]
returns = close_px.pct_change()
#这里的percentileofscore是指，0.02在x中的位置是x中的百分比
#AAPL %2回报率的百分等级
score_at_2percent = lambda x:percentileofscore(x,0.02)
result = pd.rolling_apply(returns.AAPL,250,score_at_2percent)
result.plot()
plt.show()
 
===============================================ITchat包===================================================
 
#encoding=gbk
import itchat
itchat.login()
friends=itchat.get_friends(update=True)[0:]
male=female=other=0
for i in friends[1:]:
 sex=i['Sex']
 if sex==1:male+=1
 elif sex==2:female+=1
 else:other+=1
    
total=len(friends[1:])
malecol=round(float(male)/total*100,2)
femalecol=round(float(female)/total*100,2)
othercol=round(float(other)/total*100,2)
print('男性朋友：%.2f%%' %(malecol)+'\n'+'女性朋友:%.2f%%' % (femalecol)+'\n'+'性别不明的好友：%.2f%%' %(othercol))
print("显示图如下：")
 
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
#解决中文乱码不显示问题
mpl.rcParams['font.sans-serif'] = ['SimHei'] #指定默认字体 
mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题 
  
map = {'Female': (malecol, '#7199cf'),'Male': (femalecol, '#4fc4aa'),'other': (othercol, '#e1a7a2')}
  
fig = plt.figure(figsize=(5,5))# 整体图的标题
ax = fig.add_subplot(111)#添加一个子图
ax.set_title('Gender of friends')
  
xticks = np.arange(3)+0.15# 生成x轴每个元素的位置
bar_width = 0.5# 定义柱状图每个柱的宽度
names = map.keys()#获得x轴的值
values = [x[0] for x in map.values()]# y轴的值
colors = [x[1] for x in map.values()]# 对应颜色
  
bars = ax.bar(xticks, values, width=bar_width, edgecolor='none')# 画柱状图，横轴是x的位置，纵轴是y，定义柱的宽度，同时设置柱的边缘为透明
ax.set_ylabel('Proprotion')# 设置标题
ax.set_xlabel('Gender')
ax.grid()#打开网格
ax.set_xticks(xticks)# x轴每个标签的具体位置
ax.set_xticklabels(names)# 设置每个标签的名字
ax.set_xlim([bar_width/2-0.5, 3-bar_width/2])# 设置x轴的范围
ax.set_ylim([0, 100])# 设置y轴的范围
for bar, color in zip(bars, colors):
 bar.set_color(color)# 给每个bar分配指定的颜色
 height=bar.get_height()#获得高度并且让字居上一点
 plt.text(bar.get_x()+bar.get_width()/4.,height,'%.2f%%' %float(height))#写值
plt.show()
#画饼状图
fig1 = plt.figure(figsize=(5,5))# 整体图的标题
ax = fig1.add_subplot(111)
ax.set_title('Pie chart')
labels = ['{}\n{} %'.format(name, value) for name, value in zip(names, values)]
ax.pie(values, labels=labels, colors=colors)#并指定标签和对应颜色
plt.show()
 
 
#用来爬去各个变量
def get_var(var):
 variable=[]
 for i in friends:
  value=i[var]
  variable.append(value)
 return variable
  
#调用函数得到各个变量，并把数据存到csv文件中，保存到桌面
NickName=get_var('NickName')
Sex=get_var('Sex')
Province=get_var('Province')
City=get_var('City')
Signature=get_var('Signature')
  
pros=set(Province)#去重
prosarray=[]
for item in pros:
 prosarray.append((item,Province.count(item)))#获取个数
def by_num(p):
 return p[1]
prosdsored=sorted(prosarray,key=by_num,reverse=True)#根据个数排序
 
 
#画图
figpro = plt.figure(figsize=(10,5))# 整体图的标题
axpro = figpro.add_subplot(111)#添加一个子图
axpro.set_title('Province')
xticks = np.linspace(0.5,20,20)# 生成x轴每个元素的位置
bar_width = 0.8# 定义柱状图每个柱的宽度
pros=[]
values = []
count=0
for item in prosdsored:
 pros.append(item[0])
 values.append(item[1])
 count=count+1
 if count>=20:
  break
  
colors = ['#FFEC8B','#FFE4C4','#FFC125','#FFB6C1','#CDCDB4','#CDC8B1','#CDB79E','#CDAD00','#CD96CD','#CD853F','#C1FFC1','#C0FF3E','#BEBEBE','#CD5C5C','#CD3700','#CD2626','#8B8970','#8B6914','#8B5F65','#8B2252']# 对应颜色
  
bars = axpro.bar(xticks, values, width=bar_width, edgecolor='none')
axpro.set_ylabel('人数')# 设置标题
axpro.set_xlabel('省份')
axpro.grid()#打开网格
axpro.set_xticks(xticks)# x轴每个标签的具体位置
axpro.set_xticklabels(pros)# 设置每个标签的名字
axpro.set_xlim(0,20)# 设置x轴的范围
axpro.set_ylim([0, 100])# 设置y轴的范围
  
for bar, color in zip(bars, colors):
 bar.set_color(color)# 给每个bar分配指定的颜色
 height=bar.get_height()#获得高度并且让字居上一点
 plt.text(bar.get_x()+bar.get_width()/4.,height,'%.d' %float(height))#写值
plt.show()
 
#保存数据
from pandas import DataFrame
data={'NickName':NickName,'Sex':Sex,'Province':Province,'City':City,'Signature':Signature}
frame=DataFrame(data)
frame.to_csv('C:/Users/admin/Desktop/pyda/data.csv',index=True)
==========================================================================================================
 
===============================================math,numpy包===================================================
------------------------------------------------------moudel of Math
csdn_s:   https://blog.csdn.net/Waitfou/article/details/61614400
csdn_2:   https://blog.csdn.net/lijiahong2012/article/details/52416400
public:   https://docs.python.org/3.6/library/math.html
import math 
math.ceil(x)
#1.math basic
dir(math)                        查看所有函数名列表
help(math)                       查看具体定义及函数0原型
ex:help(math.ceil)
#2.normal function
ceil(x)help(math)取顶
floor(x)                         取底
fabs(x)                          取绝对值
factorial (x)                    阶乘
hypot(x,y)                       sqrt(x*x+y*y)
pow(x,y)                         x的y次方
sqrt(x)                          开平方
exp(x)                           e**x
log(x)
log10(x)
trunc(x)                         截断取整数部分
isnan (x)                        判断是否NaN(not a number)
degree (x)                       弧度转角度
radians(x)                       角度转弧度
acos(x)                          x 的反余弦
asin(x)                          x 的反正弦。
atan(x)                          x 的反正切。
cos(x)                           x 的余弦。
sin(x)                           x 的正弦。
tan(x)                           x 的正切。
log(x,a)                         a底log函数
erf(x)                           x的误差函数
erfc(x)                          余误差函数
gamma(x)                         x的伽玛函数
lgamma(x)                        x的绝对值的自然对数的伽玛函数
 
 
#3.random
import random
random.random()                  产生一个[0.0,1.0)的随机浮点数
[random.random() for _ in range(10)]         10个
random.uniform(a,b)              产生一个[a,b]的随机浮点数
random.randint(a,b)              产生一个[a,b]的随机整数,a<=b
random.randrange(start, stop, [step])            从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random.choice(sequence)          随机取值                                 
ex：random.choice([1,2,3,4])
random.shuffle(x[, random])      用于将一个列表中的元素打乱                
ex: a=[1,2,3,4,5]  random.shuffle(a) --->[5,2,3,1,4]
random.sample(sequence, k)       从指定序列中随机获取k个元素作为一个片段返回，sample函数不会修改原有序列
ex:a = [1,2,3,4,5]   random.sample(a,3) --->从a中随机取3个值
 
#4.decimal
from decimal import Decimal
Decimal('0.1') / Decimal('0.3')   --->Decimal('0.3333333333333333333333333333') 
from decimal import getcontext
getcontext().prec = 4             设置全局精度
Decimal('0.1') / Decimal('0.3')   --->then result is Decimal('0.3333')
 
#5.fractions   转换成分子分母的形式 接受 字符串，浮点数，整数
from fractions import Fraction
ex: Fraction(16, -10)              --->Fraction(-8, 5)
ex: Fraction(123)                  --->Fraction(123, 1)
ex: Fraction('3/7')                --->Fraction(3, 7)
ex: Fraction('-.125')              --->Fraction(-1, 8)
ex: Fraction(2.25)                 --->Fraction(9, 4)
 
ex: a = Fraction(1,2)
ex: a                              --->Fraction(1, 2)
ex: b = Fraction('1/3')
ex: b                              --->Fraction(1, 3)
ex: a + b                          --->Fraction(5, 6)
ex: a - b                          --->Fraction(1, 6)
 
#6.数学常数
math.e = 2.718281828459045
math.pi = 3.141592653589793
 
https://www.cnblogs.com/TensorSense/p/6795995.html
--------------------------------------------------numpy函数
a = np.arange(15).reshape(3, 5) 
.ndim                                          ：维度 
.shape                                         ：各维度的尺度 （2，5） 
.size                                          ：元素的个数 10 
.dtype                                         ：元素的类型 dtype(‘int32’) 
.itemsize                                      ：每个元素的大小，以字节为单位 ，每个元素占4个字节 
---------------ndarray数组的创建 
np.arange(n)                                   : 元素从0到n-1的ndarray类型 
np.ones((a,b)，ddtype = np.int64)              : 生成a行b列的全1矩阵
np.full((a,b), val)                            : 生成a行b列的全val矩阵 
np.eye(n)                                      : 生成单位矩阵(仅对角线为1)
np.ones_like(a)                                : 按数组a的形状生成全1的数组 
np.zeros_like(a)                               : 同理 
np.full_like (a, val)                          : 同理
np.linspace(1,10,4)                            : 根据起止数据等间距地生成数组 
np.linspace(1,10,4, endpoint = False)          : endpoint 表示10是否作为生成的元素 
np.concatenate()                               : 数组拼接数组
 
---------------数组的维度变换
.reshape(shape)                                : 不改变当前数组，依shape生成 
.resize(shape)                                 : 改变当前数组，依shape生成 
.swapaxes(ax1, ax2)                            : 将两个维度调换 
.flatten()                                     : 对数组进行降维，返回折叠后的一位数组
 
---------------一维数组切片
a = np.array ([9, 8, 7, 6, 5, ]) 
a[1:4:2] –> array([8, 6])                      ：a[起始编号：终止编号（不含）： 步长]
---------------多维数组索引
a = np.arange(24).reshape((2, 3, 4)) 
a[1, 2, 3]                                     : 表示 3个维度上的编号， 各个维度的编号用逗号分隔
---------------多维数组切片
a [：，：，：：2 ] 缺省时，表示从第0个元素开始，到最后一个元素 
 
 
---------------数组的运算 
np.abs(a)/np.fabs(a)                          : 绝对值 
np.sqrt(a)                                    : 平方根 
np.square(a)                                  : 平方 
np.log(a)/np.log10(a)/np.log2(a)              : 自然对数、10、2为底的对数 
np.ceil(a)/np.floor(a)                        : ceiling 值， floor值（ceiling向上取整，floor向下取整） 
np.rint(a)                                    : 四舍五入 
np.modf(a)                                    : 将小数和整数 部分以两个独立数组形式返回 
np.exp(a)                                     : 指数值 
np.sign(a)                                    : 符号值 1（+），0，-1（-） 
np.maximum(a, b)/np.fmax()                    : 计算元素级的最大值np.fmax([1,2,3,2],[2,3,4,1])->2342
np.minimum(a, b)/np.fmin()                    : 取最小值 
np.mod(a, b)                                  : 元素级的模运算 
np.copysign(a, b)                             : 将b中各元素的符号赋值给数组a的对应元素
 
 
---------------数据的CSV文件存取
CSV (Comma-Separated Value,逗号分隔值) 只能存储一维和二维数组
np.savetxt(frame, array, fmt=’% .18e’, delimiter = None)
---frame是文件、字符串等，可以是.gz .bz2的压缩文件
---array 表示存入的数组 
---fmt 表示元素的格式 eg： %d % .2f % .18e  
---delimiter:分割字符串，默认是空格 
eg： np.savetxt(‘a.csv’, a, fmt=%d, delimiter = ‘,’ )
 
np.loadtxt(frame, dtype=np.float, delimiter = None, unpack = False) 
---frame是文件、字符串等，可以是.gz .bz2的压缩文件
---dtype：数据类型，读取的数据以此类型存储
---:delimiter: 分割字符串，默认是空格
---unpack: 如果为True， 读入属性将分别写入不同变量。 
 
多维数据的存取 
a.tofile(frame, sep=’’, format=’%s’ ) 
---frame:    文件、字符串
---sep:      数据分割字符串，如果是空串，写入文件为二进制 
---format:   写入数据的格式 
---eg: a = np.arange(100).reshape(5, 10, 2)    a.tofile(“b.dat”, sep=”,”, format=’%d’)
 
np.fromfile(frame, dtype = float, count=-1, sep=’’)
---frame：文件、字符串
---dtype：读取的数据以此类型存储
--count： 读入元素个数， -1表示读入整个文件
---sep:   数据分割字符串，如果是空串，写入文件为二进制
 
PS: a.tofile() 和np.fromfile（）要配合使用，要知道数据的类型和维度。
 
np.save(frame, array) : frame: 文件名，以.npy为扩展名，压缩扩展名为.npz ； array为数组变量 
np.load(fname) : frame: 文件名，以.npy为扩展名，压缩扩展名为
 
np.save() 和np.load() 使用时，不用自己考虑数据类型和维度。
 
 
---------------numpy随机数函数
---numpy.random
b=np.random.randint(100,200,10)
rand(d0, d1, …,dn)                        : [0, 1）的浮点数，服从均匀分布 
randn(d0, d1, …,dn)                       ：标准正态分布 
randint(low， high,())                    :依shape创建随机整数或整数数组，范围是[low, high） 
seed(s)                                   ：随机数种子
shuffle(a)                                : 根据数组a的第一轴进行随机排列，改变数组a 
permutation(a)                            :根据数组a的第一轴进行随机排列， 不改变原数组，将生成新数组 
choice(a, size, replace, p)               : 从一维数组a中以概率p抽取元素， 形成size形状新数组，replace表示是否可以重用元素，默认为True。  
eg:---> np.random.choice(b,(2,3),p=b/np.sum(b))          从b中按（2,3）型状&概率p 进行随机抽样（设置replace=True 做不放回抽样）
 
 
uniform(low, high, size)                 : 产生均匀分布的数组，起始值为low，high为结束值，size为形状 
normal(loc, scale, size)                 : 产生正态分布的数组， loc为均值，scale为标准差，size为形状 
poisson(lam, size)                       : 产生泊松分布的数组， lam随机事件发生概率，size为形状 
eg: a = np.random.uniform(0, 10, (3, 4)) a = np.random.normal(10, 5, (3, 4))
 
 
---------------numpy的统计函数
sum(a, axis = None)                      : 依给定轴axis计算数组a相关元素之和，axis为整数或者元组 
mean(a, axis = None)                     : 同理，计算平均值 
average(a, axis =None, weights=None)     : 依给定轴axis计算数组a相关元素的加权平均值 
std（a, axis = None）                    ：同理，计算标准差 
var（a, axis = None）                    : 计算方差 
eg： np.mean(a, axis =1)                 ： 对数组a的第二维度的数据进行求平均 
a = np.arange(15).reshape(3, 5) 
np.average(a, axis =0, weights =[10, 5, 1]) : 对a第一各维度加权求平均，weights中为权重，注意要和a的第一维匹配
 
min(a)/max(a)                            : 计算数组a的最小值和最大值 
argmin(a)/argmax(a)                      : 计算数组a的最小、最大值的下标（注：是一维的下标） 
unravel_index(index, shape)              : 根据shape将一维下标index转成多维下标 
ptp(a)                                   : 计算数组a最大值和最小值的差 
median(a)                                : 计算数组a中元素的中位数（中值） 
eg：a = [[15, 14, 13], 
[12, 11, 10] ] 
np.argmax(a) –> 0 
np.unravel_index( np.argmax(a), a.shape) –> (0,0)
----numpy的梯度函数
np.gradient(a)                            ：计算数组a中元素的梯度，f为多维时，返回每个维度的梯度 
离散梯度：xy坐标轴连续三个x轴坐标对应的y轴值：a, b, c 其中b的梯度是（c-a）/2  而c的梯度是： (c-b)/1
 
当为二维数组时，np.gradient(a) 得出两个数组，
第一个数组对应最外层维度的梯度，第二个数组对应第二层维度的梯度。
================================================调用mysql做分词=======================================================
#coding=gbk
#encode=utf-8  
import pymysql
import jieba
import pandas as pd
from os import path
from wordcloud import WordCloud
import matplotlib.pyplot as plt
from numpy import *
from pandas import *
from datetime import datetime
from dateutil.parser import parse
from datetime import datetime
try:
    conn = pymysql.connect(host='localhost',user='root',passwd='zieox888',db='sys',port=3306,charset='utf8')
    df = pd.read_sql(select ct.`date` dt,CAST(ct.settle AS SIGNED) se,CAST(ct.recharge AS SIGNED) re from ct, con=conn) 
    conn.close()
    print ("finish load db")
except pymysql.Error:print (e.args[1])
pd.to_datetime(df.dt)
 
--------#usedway
'''db = pymysql.connect(host='localhost',port = 3306,user='root',passwd='zieox888',db ='sys', charset='utf8')
cursor = db.cursor()
cursor.execute("select * from ctsl")
da=cursor.fetchall()
ti,s1,s2,s3=[],[],[],[]
'''for rec in da:
	l1.append(rec[3])'''
for i in da:
	ti.append(parse(i[0]).strftime('%Y-%m-%d')[0:-1])
	s1.append(int(i[11]))
	s2.append(float(i[13]))
	s3.append(float(i[12]))
print(ti)
#print(pd.value_counts(pd.qcut(s1,4)))#4分位切割'''
 
#步段图+虚线
plt.plot(s1,'k--',label='Default')
plt.plot(s2,'k-',drawstyle='steps-post',label='steps-post')
plt.legend(loc='best')
 
#3线图（logsi） 
fig=plt.figure()
ax=fig.add_subplot(1,1,1)
ax.plot(s1,'k',label='logPnum')
ax.plot(s2,label='signum')
ax.plot(s3,'k-',label='lognum')
labels=ax.set_xticklabels(ti,rotation=30,fontsize='small') #设置x轴标签
ax.set_title('ctsllog info')
ax.set_xlabel('date')
plt.show
 
--------------#写入文件与rows
numrows = cursor.rowcount
datacol=[]
for i in range(numrows):
	row = cursor.fetchone()
	datacol.append(row[4])	
for i in datacol:
	with open(path,'w') as obj:
		obj.write(str(i)+'\n')
----------------	
totast=[]
idd=[]
x=list(range(1,len(data)+1))
for i in data : totast.append(int(float(i[24])))
pl.title('Assets distribution of shanghai',fontsize=20)
pl.ylabel('$ of assets',fontsize=12)
pl.scatter(x,totast,s=8)
pl.axes().get_xaxis().set_visible(False)
pl.show()
 
--------#有逗号的分词统计
word_lst = []  
word_dict= {}  
for word in datacol[:10]:  
	word_lst.append(word.split(','))
	for item in word_lst:
		for item2 in item:
			if item2 not in word_dict:word_dict[item2] = 1
			else:word_dict[item2] += 1
	for key in word_dict:print(key,word_dict[key])
 
--------#分词统计
print ('【Output】')
text=open(path,'rb').read()
print('There are :'+str(len(text))+' words ')
words = [x for x in jieba.cut(text,cut_all=False) if len(x) > 1]
from collections import Counter
c = Counter(words).most_common(500)
d1={h:v for h,v in c}
print(d1)
 
---------#写入txt
with open('2.txt','w') as obj:
	for i in c:
		obj.write(str(i)+'\n')
		print(i)