python pandas学习笔记

import pandas as pd

import numpy as np

4.1 Serices

1. Serices创建

创建空的系列

S1=pd.Series()

创建默认index的Series

S2=pd.Series([1,3,5,7,9])

创建指定index的Series

S2=pd.Series([1,3,5,7,9], index=[‘a’,’b’,’c’,’d’,’e’])

2. Serices对象的元素提取

调用方法提取元素

S4=pd.Series([0,np.NaN,2,4,6,8,True, 10, 12])
S4.head() #默认获取前5个数据
S4.head(3)
S4.tail()#默认获取后5个数据
S4.tail(6)
S4.take([2,4,0])#指定索引值

利用位置提取元素

S5= pd.Series([1,3,5,7,9],\
index=['a','b','c','d','e'])
S5[2]           #位置提取
S5[[1,3,4]]     #多个位置提取
S5[0:4]         #切片

利用标签提取元素

S5= pd.Series([1,3,5,7,9],\
index=['a','b','c','d','e'])
S5['d']              #标签提取
S5[['b','e','d']]    #多个标签提取
S5['a':'d']          #切片

3. 时间系列

时间系列分析在金融数据中占据重要位置

from datetime import datetime

import pandas as pd

date = datetime(2016,1,1)
date = pd.Timestamp(date)
date
type(date)
ts=pd.Series(1,index=[date])
ts
ts.index
ts.index[0]

dates = ['2016-01-01','2016-01-02','2016-01-03']
ts=pd.Series([1,2,3],index=pd.to_datetime(dates))
ts
ts.index
ts.index[0]

dates = [datetime(2016,1,1),datetime(2016,1,2),datetime(2016,1,3)]
ts=pd.Series([1,2,3],index=dates)
ts.index[0]
ts['20160101']
ts['2016-01-01']
ts['01/01/2016']

ts
ts['2016']
ts['2016-01':'2016-02']
ts.truncate(after='2016-01-02')
ts.shift(1) #正数为滞后
ts.shift(-1) #负数为超前

price=pd.Series([20.34,20.56,21.01,20.65,21.34],\
index=pd.to_datetime(['2016-01-01','2016-01-02',\
'2016-01-03','2016-01-04','2016-01-05']))
(price-price.shift(1))/price.shift(1)

ts.index.freq is None
rts=ts.resample('M',how='first') #'M'指的是每月最后一天
rts
rts=ts.resample('MS',how='first') #'MS'指的是每月的第一天
rts

4.2 DataFrame

import pandas as pd

import numpy as np

1. 创建DataFrame对象

dates = ['2016-01-01','2016-01-02','2016-01-03',
'2016-01-04','2016-01-05','2016-01-06']
dates=pd.to_datetime(dates)
dates

#由于随机的关系，接下来跑出的结果会和书上内容不同
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))

2. 查看DataFrame对象

df.head(3)
df.tail(4)
df.columns
df.index
df.values
df.describe()

3. DataFrame对象的索引与切片

DataFrame 行与列的单独操作

df[1:3]           #行操作
df['A']           #列操作
df[['A','C']]     #多列操作
df[df['A']>0]     # bool值操作

标签索引与切片

df.loc[:,'A']                  #提取A列数据
df.loc[:,'A':'C']              #提取A、C列数据
df.loc[dates[0:2],'A':'C']     #提取1-2行的A、C列数据
df.loc[dates[0],'A']           #提取1行的A列数据
df.at[dates[0],'A']            #提取1行的A列数据
df.loc[df.loc[:,'A']>0]        #提取A列大于0的行

位置索引与切片

df.iloc[2]                      #提取第3行数据
df.iloc[:,2]                    #提取第3列数据
df.iloc[[1,4],[2,3]]            #提取行为1,4，列为2,3的数据
df.iloc[1:4,2:4]                #提取行为1-4，列为2-4的数据
df.iloc[3,3]                    #提取行为3，列为3的数据
df.iat[3,3]                     #提取行为3，列为3的数据
df.loc[:,df.iloc[3]>0]          #提取第3列大于0的行

广义索引与切片

df.ix[2:5]                      #提取行2-5数据
df.ix[[1,3],2]                  #
df.ix[[1,3],'C']                #
df.ix[1:3,'A':'C']              #
df.ix[1:3,df.iloc[3]>0]         #

4. DataFrame的操作

转置

df.T

排序与排名

df.sort(axis=0, ascending=False)   #按行标签排序
df.sort(axis=1, ascending=False)   #按列标签排序
df.sort(columns='C')               #按列排序
df
df.rank(axis=0)
df.rank(axis=1,ascending=False)

增加列

#增加E列
s1=pd.Series([1,2,3,4,5,6],index=pd.date_range('20160102',periods=6))
df['E'] = s1

增加行

方式1：

df1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]},\
index=pd.date_range('20160110',periods=3))
df.append(df1)

方式2：

data=np.arange(7,15,4)
date=pd.to_datetime('20160101')
df1.ix[date]=data

方式3：

pd.concat([df,df1],join='inner')

删除操作

df.drop(dates[1:3])          #删除行1-3的数据，df并没有删除
df.drop('A',axis=1)          #删除列A的数据，注意删除列时，需要指定axis=1
del df['A']                  #删除列A的数据，df并没有删除
df.drop(dates[1:3],inplace=True) #删除行1-3的数据，df相应行删除

替换操作

df.loc[dates[2],'C'] = 0
df.iloc[0,2] = 0
df.loc[:,'B'] = np.arange(0,len(df))   #替换B列

df.ix[date]=data                       #替换date所在行的数据

5. DataFrame的运算

简单运算

Series与Series运算

匹配规则： index与 index，如不能匹配，就用NaN

s1=pd.Series([1,2,3],index=list('ABC'))
s1
s2=pd.Series([4,5,6],index=list('BCD'))
s2
s1+s2

Out[826]:
A    NaN
B    6.0
C    8.0
D    NaN
dtype: float64

Series与DataFrame运算

匹配规则： index与 column，如不能匹配，就用NaN

每行元素都进行列的操作

df1=pd.DataFrame(np.arange(1,13).reshape(3,4),
index=list('abc'),columns=list('ABCD'))

df1-s1

Out[828]:
A    B    C   D
a  0.0  0.0  0.0 NaN
b  4.0  4.0  4.0 NaN
c  8.0  8.0  8.0 NaN

DataFrame与DataFrame运算

匹配规则： 同时index与 column匹配，如不能匹配，就用NaN

每行元素都进行列的操作

df2=pd.DataFrame(np.arange(1,13).reshape(4,3),
index=list('bcde'),columns=list('CDE'))
df1*df2

Out[834]:
A   B     C     D   E
a NaN NaN   NaN   NaN NaN
b NaN NaN   7.0  16.0 NaN
c NaN NaN  44.0  60.0 NaN
d NaN NaN   NaN   NaN NaN
e NaN NaN   NaN   NaN NaN

如当不能匹配时，可以使用其他的数据替换’NaN’

函数应用和映射

函数基本形式为: DataFrame.apply(func,axis=0)

df0 = pd.DataFrame(np.random.rand(6,4),
index=pd.date_range('20160101',periods=6),
columns=list('ABCD'))

df0.apply(max,axis=0)
Out[838]:
A    0.945795
B    0.695932
C    0.923623
D    0.594854
dtype: float64

也可以使用自定义函数

f=lambda x: x.max()-x.min()
df0.apply(f,axis=1)

6. 数据规整化

缺失值处理

缺失值判断

df3=df1.mul(df2,fill_value=0)
df3.isnull()
df3.notnull()

-选出不是缺失值的数据

df3.B[df3.B.notnull()]

缺失值的填充

df4=pd.DataFrame(np.random.rand(5,4),
index=list('abcde'),
columns=list('ABCD'))
df4.ix['c','A']=np.nan
df4.ix['b':'d','C']=np.nan
df4
df4.fillna(0)                                 #指定数值填充
df4.fillna(method='ffill')                    #前一个观测值填充，列方向
df4.fillna(method='bfill')                    #后一个观测值填充，列方向
df4.fillna(method='backfill',axis=1)          #后一个观测值填充，行方向
df4.fillna(method='pad',limit=2)              #连续NaN的值按照limit指定个数填充，取前一个值，列方向
df4.fillna('missing', inplace=True)           #填充后，替代原dataFrame

缺失值的选择删除

DataFrame.dropna(axis=0,how=’any’,thresh=None)

axis=0:指删除包含NaN的行， axis=1 指删除包含NaN的列

how:how=’any’指只要有缺失值就删除该行，how=’all’指所有元素都为缺失值就删除该行、列

thresh：比如thresh=5表示当改行或者列的缺失值大于或者等于5时，就删除该行或者列

df4.dropna(axis=0)
df4.dropna(axis=1,thresh=3)
df4.dropna(axis=1,how='all')

删除重复值

df5=pd.DataFrame({'c1':['apple'] *3 + ['banana']*3+['apple'],
'c2':['a', 'a', 3, 3, 'b', 'b','a']})
df5
df5.duplicated()
df5.drop_duplicates()         #所有列都相同的数据行
df5.duplicated(['c2'])
df5.drop_duplicates(['c2'])   #指定列相同的数据行

7.重要函数

numpy.in1d 判断两个ndarray中的元素是否相同

numpy.random.uniform 获取多少以内的数据若干