pandas基础

pandas基本特征

官方文档
1.自动数据对齐
2.灵活处理缺失数据

数据结构及基本操作

Series

import numpy as np
import pandas as pd 

# >>>构造
se1=pd.Series(range(4))
se2=pd.Series(range(4),index=list('abcd'),name='sername') #设置index和name
sdata=dict(zip(list('abcd'),range(4)))
se3=pd.Series(sdata) #传入字典数据
se4=pd.Series(sdata,index=list('bcde')) #a不显示，e为np.nan

se1.name
se1.values #返回ndarray
se1.index #返回Index
se1.index.name #index为multiIndex时，属性为names
se1.index=list('abcd') #这里行数必须匹配
'a' in se2

DataFrame

# >>>构造
data1={'state':list('abcd'),
  'year':np.random.randint(low=2000,high=2010,size=4),
  'pop':np.random.rand(4)*10}
df1=pd.DataFrame(data1) #键为列名
df2=pd.DataFrame(data1,columns='year,state,pop'.split(',')) #按新列名排序
df3=pd.DataFrame(data1,columns='year,state,pop,debt'.split(','),
  index='one,two,three,four'.split(',')) #debt列为NaN

data4={'a':{2001:2.4,2002:2.9},'b':{2000:1.5,2001:1.7}}
df4=pd.DataFrame(data4) #外键为列，内键为行，缺失索引为NaN

data5={'a':df4.a,'b':df4.b}
df5=pd.DataFrame(data5) #与df4同理

data6=[{'a':1,'b':2},{'a':3,'c':4}]
df6=pd.DataFrame(data6) #每个对象为1行，对象的键为列

df3.columns
df3.columns.name #index为multiIndex时，属性为names
df3['debt']=pd.Series(range(7,10),index='two,four,five'.split(',')) #缺失索引为NaN
df3.state #返回Series
del df3['debt'] #在其本身删除列
df3.T #行列转置，元数据视图

Textparsers

from pandas.io.parsers import TextParser

data=[[1,2],[3,4],[5,6]]

# 读取前n行
df=TextParser(data,names=['text','add']).get_chunk(1)

Index

# >>>构造
ix1=pd.Index(np.arange(3),name='indexname')
ix2=pd.Index(list('aabc')) #可带重复值
mxix=MultiIndex.from_arrays([['a','b','c'],['one','two','three']],
  names=['state','color'])

ix1 is pd.Index
ix1[2:] #切片索引
#ix1[2]=10 #不可修改
2 in ix1 #值得成员资格

Index对象

类	说明
Index	最泛华的对象，表示为Numpy数组
Int64Index	针对整数的特殊Index
MultiIndex	层次化索引对象，表示单轴多层索引，可看做由元组组成的数组
DatetimeIndex	存储纳秒级时间拽，用np.datetime64类型表示
PeriodIndex	针对Period数据（时间间隔）的特殊Index

Index的方法及属性

方法	说明
append	链接另外一个Index，产生新的Index
diff	计算差集，产生新的Index
intersection	计算交集
union	计算并集
isin	计算在另一个数组的成员资格，返回bool型数组
delete	删除索引i处的元素，产生新的Index
drop	删除指定元素值，产生新的Index
insert	将元素插入到索引i处，产生新的Index
is_monotonic	当各元素均大于前一元素时，返回True
is_unique	当Index没有重复着，返回True
unique	返回Index中唯一值得数组

Panel

import pandas.io.data as web
data=dict((stk,web.get_data_yahoo(stk,'1/12009','6/1/2012')) for stk in ['AAPL','GOOG'])
pdata=pd.Panel(data) #Panel的没一项（类似列）都是DataFrame
stacked=pdata.ix[:,:,:].to_frame() #表行列
unstack=stacked.to_panel()

Panel与DataFrame的转换
Index的方法及属性

方法	说明
to_frame	返回堆叠的DataFrame
to_panel	返回不堆叠的Panel

基本功能

重新索引

reindex

se2=se2.reindex(index=list('edcba'),fill_value=0)
se2=se2.reindex(index=list('edcba'),method='ffill')

df=pd.DataFrame(np.arange(9).reshape(3,3),
  index=['a','b','c'],columns='year,state,pop'.split(',')) 
df=df.reindex(index=['a','b','c','d'],
  columns='year,state,pop,debt'.split(','),
  method='ffill') 
df.ix[['a','b','c','d'],'year,state,pop,debt'.split(',')]

reindex的method选项

参数	说明
ffill或pad	向前填充或搬运
bfill或backfill	向后填充或搬运

reindex函数的参数

参数	说明
index	用作索引的新序列
method	插值方式
fill_value	需要引入缺失值时使用的替代值
limit	向前或向后填充是的最大填充量
level	再MultiIndexd的指定级别上匹配简单索引，否则选取其子集
copy	默认True，为False时新旧相等不复制

丢弃轴

drop

se=pd.Series(np.arange(5.),index=list('abcde'))
newse=se.drop('c')
newse=se.drop(['a','b'])

df=pd.DataFrame(np.arange(16).reshape((4,4)),
  index=list('abcd'),
  columns='one,two,three,four'.split(','))
df.drop(['a','c'])
df.drop('two',axis=1)
df.drop(['one','three'],axis=1,inplace=False)

索引选取，过滤

se['b']
se[1]
se[b:c]
se[1:2]
se[['b','a','c']]
se[[1,0,2]]
se[se<2]

df['two']
df[['three','one']]
df[:2] #返回2行所有列
df[df['three']>5] #返回符合条件行和所有列
df<5 #返回bool型2d数据
df.ix['b',['two','three']]
df.ix[['b','c'],[3,0,1]]
df.ix[2]
df.ix[:'c','two']
df.ix[:,'one':'two']
df.ix[df.three>5,:3]

DataFrame索引选项

类型	说明
df[val]	选取单个列或一组列，val可以是：bool型数组（过滤行），切片（行切片），bool型DataFrame
df.ix[val]	选取单个行，一组行，或切片行
df.ix[:val]	选取单个列，一组列，或切片列
df.ix[val,val]同时选取行和列
reindex	将一个或多个轴匹配到新索引
xs	根据标签选取单行或单列，返回Series
icol,irow	根据整数位选取单行或单列，返回Series
get_value,set_value	根据行标签和列标签选取或设置单个值

算数运算和数据对齐

se1=pd.Series(range(4),index=list('acde'))
se2=pd.Series(range(10,15),index=list('acefg'))
se1+se2  #不重叠索引为NaN,确实值在运算过程中传播

df1=pd.DataFrame(np.arange(9.).reshape((3,3)),index='two,three,six'.split(','),columns=list('bcd'))
df2=pd.DataFrame(np.arange(12.).reshape((4,3)),index='one,two,three,four'.split(','),columns=list('bde'))
df1+df2 #索引和列为原来的并集
df1.add(df2,fill_value=0)

#DataFrame和Series之间的运算
se=pd.Series(range(3),index=list('bef'))
df2+se
se3=df2['d']
df2.sub(se3,axis=0) #按行匹配

算数方法

类型	说明
add	加
sub	减
mul	乘
div	除

函数应用和映射

df=pd.DataFrame(np.random.randn(4,3),
  columns=list('bde'),
  index='one,two,three,four'.split(','))

df.apply(lambda x:x.max()-x.min()) #值x传入Series
df.apply(lambda x:x.max()-x.min(),axis=1) #以列为对象，计算属性行

df.apply(lambda x:pd.Series([x.min(),x.max()],index=['min','max']))

format=lambda x:'%.2f'%x
df.applymap(format) #格式化

df['e'].map(format) #Series格式化

排序和排名

se=pd.Series(range(4),index=list('dabc'))
df=pd.DataFrame(np.arange(8).reshape((2,4)),
  index=['three','one'],
  columns=list('dabc'))

se.sort_index()
se.order(ascending=False) #按值排列,NaN值默认排在末尾
df.sort_index(axis=1,ascending=False)
df.sort_index(by=['a','c'])

se.rank(ascending=Flase,method='min') #计算器值得排名
df.rank(axis-1)

rank的method选项

选项	说明
‘average’	默认，平均排名
‘min’	最小排名
‘max’	最大排名
‘first’	原始排名

汇总及描述统计

约简方法选项

类型	说明
axis	约简的轴
skipna	排除NaN，默认为True
level	如果是层次化索引（MultiIndex），则根据指定level分组约简

汇总和描述统计方法

方法	说明
count	非NaN值的数量
describe	列出计算汇总统计
min,max	最小值和最大值
argmin,argmax	最小值和最大值的索引位置（整数）
idxmin,idxmax	最小值和最大值的索引值
quantile	计算样本分位数（0-1）
sum	总和
mean	平均数
median	中位数（50%）分位数
mad	根据平均值计算平均绝对离差
var	方差
std	标准差
skew	样本值的偏度（三阶矩）
kurt	峰度（四阶矩）
cumsum	累积和
cummin，cummax	累计最小值，累计最大值
cumprod	累计积
diff	一阶差分
pct_change	百分比变化

相关系数与协方差

se1.corr(se2) #相关系数
se1.cov(se2) #协方差

df.corr() #各列得的相互的相关系数
df.cov() #各列得的相互的协方差

df.corrwith(se) #各列与指定se的相关系数

唯一值，值计数，成员资格

df=pd.DataFrame({'Q1':[1,3,4,3,4],
  'Q2':[2,3,1,2,3],
  'Q3':[1,5,2,4,4]})
data.apply(pd.value_counts).fillna(0)

唯一值，值计数，成员资格

方法	说明
isin	计算Series成员资格，返回布尔型数组
unique	计算Series唯一值数组，按发现顺序返回
value_counts	计算值频率，降序排列

处理缺失数据

se4.isnull();pd.isnull(se4) #返回bool型数据
se4.notnull();pd.notnull(se4) #返回bool型数据

df=pd.DataFrame(np.random.randn(7,3))
df.ix[:4,:1]=np.nan;df.ix[:2,2]=None
df.dropna(axis=0,how='all') #过滤所有属性为NaN的对象
df.dropna(thresh=3) #过滤小于3个属性的数据的对象

NaN处理方法

方法	说明
dropna	根据各镖旗的值中是否存在缺失数据对轴紧型过滤
fillna	用指定值或差值方法（ffill，bfill）填充缺失数据
isnull	返回bool型数据对象，对象与源数据类型一致
notnull	isnull否定

fillna函数的参数

方法	说明
value	用于填充的标量值或字典对象
method	插值方式默认为ffill，还有bfill
axis	待填充的轴，默认为0
inplace	修改调用者对象而不产生副本
limit	设置可连续填充的最大数量

层次化索引

# >>>Series层次索引操作
se=pd.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]])
se['b':'c']
se[['b','d']]
se.ix[['b','d']]
se[:,2]#选内层

# >>>堆叠
se.unstack() #内层转为列
se.unstack().stack()

# >>>DataFrame层次索引操作
df=pd.DataFrame(np.arange(12).reshape((4,3)),
  index=[['a','a','b','b'],[1,2,1,2]],
  columns=[['one','one','two'],['green','red','green']])
df.index.names=['key1','key2']
df.columns.names=['state','color']
df.ix[[('a',2),('b',2)],[('one','green'),('two','green')]]

# >>>重排分级
df.swaplevel('state','color',axis=1)
df.swaplevel(0,1,axis=1)
df.sortlevel('key2')
df.sortlevel(1)

# >>>按级分组计算
df.sum(level='key2') #按指定分组计算
df.sum(level='color',axis=1) #按指定分组计算

重排分级方法

方法	说明
swaplevel	交换传入的指定分级的索引值或索引位置（整数）
sortlevel	排序指定分级的索引值或索引位置（整数）

索引设置

方法	说明
set_index	指定列名或列名列表作为index，drop选项判断是否删除指定列
reset_index	把index值作为列数据，并以range方式重置index