利用python进行数据分析之pandas库的应用（二）
本节介绍Series和DataFrame中的数据的基本手段
重新索引
pandas对象的一个重要方法就是reindex,作用是创建一个适应新索引的新对象
>>> from pandas import Series,DataFrame >>> obj=Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c']) >>> obj d 4.5 b 7.2 a -5.3 c 3.6 dtype: float64
#reindex对索引值进行重排，如果当前索引值不存在，就引入缺失值 >>> obj2=obj.reindex(['a','b','c','d','e']) >>> obj2 a -5.3 b 7.2 c 3.6 d 4.5 e NaN dtype: float64
#可以指定fill_value=0来进行缺失值的替换 >>> obj.reindex(['a','b','c','d','e'],fill_value=0) a -5.3 b 7.2 c 3.6 d 4.5 e 0.0 dtype: float64
对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理，method选项即可达到此目的：
| method参数介绍 | |
| 参数 | 说明 |
| ffill或pad | 前向填充 |
| bfill或backfill | 后向填充 |
>>> obj3=Series(['blue','red','yellow'],index=[0,2,4]) >>> obj3.reindex(range(6),method='ffill') 0 blue 1 blue 2 red 3 red 4 yellow 5 yellow dtype: object
对于DataFrame数据类型，reindex可以修改行与列索引，但如果仅传入一个序列，则优先重新索引行：
>>> DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['ohio','texas','california']) ohio texas california a 0 1 2 c 3 4 5 d 6 7 8 >>> frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['ohio','texas','california']) >>> frame2=frame.reindex(['a','b','c','d']) >>> frame2 ohio texas california a 0 1 2 b NaN NaN NaN c 3 4 5 d 6 7 8
#使用columns关键字可以对列重新索引 >>> frame.reindex(columns=['texas','utah','california']) texas utah california a 1 NaN 2 c 4 NaN 5 d 7 NaN 8
#可利用ix的标签索引功能，重新索引任务可以变得简洁
frame.ix[['a','b','c','d'],['texas','utah','california']]
texas utah california
a 1 NaN 2
b NaN NaN NaN
c 4 NaN 5
d 7 NaN 8
丢弃指定轴上的项
丢弃轴上的项很简单，使用drop方法返回的是一个在指定轴上删除指定值的新对象
>>> obj=Series(np.arange(5),index=['a','b','c','d','e']) >>> new_obj=obj.drop('c') >>> new_obj a 0 b 1 d 3 e 4 dtype: int32
#对于DataFrame，可以删除任意轴上的索引值 >>> frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['ohio','texas','california']) >>> frame.drop(['ohio'],axis=1) texas california a 1 2 c 4 5 d 7 8
索引，选取和过滤
Series利用标签的切片运算与普通的python切片运算不同，其末端是包含的，
DataFrame进行索引就是获取一个或多个列
>>> frame.drop(['ohio'],axis=1) texas california a 1 2 c 4 5 d 7 8 >>> frame ohio texas california a 0 1 2 c 3 4 5 d 6 7 8 >>> frame['ohio'] a 0 c 3 d 6 Name: ohio, dtype: int32
#也可通过切片和布尔型来选取
>>> frame[:2] ohio texas california a 0 1 2 c 3 4 5 >>> frame[frame['ohio']>=3] ohio texas california c 3 4 5 d 6 7 8
为了在DateFrame上进行标签索引，我们引入ix：
>>> frame ohio texas california a 0 1 2 c 3 4 5 d 6 7 8 >>> frame.ix['a',['ohio','texas']] #注意行标签在前，列标签在后 ohio 0 texas 1 Name: a, dtype: int32
算术运算和数据对齐
pandas最重要的功能是对不同索引的对象进行算术运算，在将对象相加时，如果存在不同的索引对，则结果就是该索引对的并集。
>>> s1=Series([7.3,-2.5,3.4,1.5],index=['a','c','d','e']) >>> s2=Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g']) >>> s1+s2 a 5.2 c 1.1 d NaN e 0.0 f NaN g NaN dtype: float64
#自动对齐操作在不重叠的索引处引入na值，缺失值会在算术运算中传播
在DataFrame中，对齐操作会同时发生在行跟列上
>>> df1=DataFrame(np.arange(9).reshape((3,3)),columns=list('bcd'),index=['ohio','texas','colorado']) >>> df2=DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['utah','ohio','texas','oregon']) >>> df1 b c d ohio 0 1 2 texas 3 4 5 colorado 6 7 8 >>> df2 b d e utah 0 1 2 ohio 3 4 5 texas 6 7 8 oregon 9 10 11 >>> df1+df2 b c d e colorado NaN NaN NaN NaN ohio 3 NaN 6 NaN oregon NaN NaN NaN NaN texas 9 NaN 12 NaN utah NaN NaN NaN NaN
#只返回行列均匹配的数值
在对不同的索引对象进行算术运算时，当一个对象中某个轴标签在另一个对象中找不到时填充一个特殊值
>>> df1 b c d ohio 0 1 2 texas 3 4 5 colorado 6 7 8 >>> df2 b d e utah 0 1 2 ohio 3 4 5 texas 6 7 8 oregon 9 10 11 >>> df1.add(df2,fill_value=0) b c d e colorado 6 7 8 NaN ohio 3 1 6 5 oregon 9 NaN 10 11 texas 9 4 12 8 utah 0 NaN 1 2
DataFrame和Series之间的算术运算也是有明确规定的，会进行一种广播运算，默认情况下DataFrame和Series之间的运算会将Series的索引匹配到DataFrame的列索引，然后沿着行一直向下传播，
>>> frame=DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['utah','ohio','texas','oregon']) >>> series=frame.ix[0] >>> frame b d e utah 0 1 2 ohio 3 4 5 texas 6 7 8 oregon 9 10 11 >>> series b 0 d 1 e 2 Name: utah, dtype: int32 >>> frame-series b d e utah 0 0 0 ohio 3 3 3 texas 6 6 6 oregon 9 9 9
如果希望匹配行索引并且在列上进行广播，则必须使用算是运算方法：
>>> frame['d'] utah 1 ohio 4 texas 7 oregon 10 Name: d, dtype: int32 >>> frame.sub(frame['d'],axis=0) b d e utah -1 0 1 ohio -1 0 1 texas -1 0 1 oregon -1 0 1
函数应用和映射
numpy的函数也可以操作pandas对象：
>>> frame=DataFrame(np.random.randn(4,3),columns=list('bde'),index=['utah','ohio','texas','oregon']) >>> frame b d e utah -1.258749 0.147998 0.250556 ohio 0.801182 -0.295881 1.377340 texas -0.281857 -0.009323 -0.520724 oregon 1.859103 0.098237 -0.475264 >>> np.abs(frame) b d e utah 1.258749 0.147998 0.250556 ohio 0.801182 0.295881 1.377340 texas 0.281857 0.009323 0.520724 oregon 1.859103 0.098237 0.475264
另一种常用的操作是，将函数应用到由各行各列所形成的一维数组上，利用apply方法可实现此功能：
>>> f=lambda x: x.max()-x.min() >>> frame.apply(f) #在行上进行操作 b 3.117851 d 0.443879 e 1.898065 dtype: float64 >>> frame.apply(f,axis=1)#在列上进行函数操作 utah 1.509304 ohio 1.673221 texas 0.511402 oregon 2.334367 dtype: float64 >>>
元素级的python函数也是适用的：
>>> format1=lambda x:'%.2f' %x >>> frame.applymap(format1) #用applymap，是因为Series有一个用于元素级函数的map方法 b d e utah -1.26 0.15 0.25 ohio 0.80 -0.30 1.38 texas -0.28 -0.01 -0.52 oregon 1.86 0.10 -0.48
排序和排名
根据条件对数据集排序也是一种重要的内置运算，对行列索引进行排序可使用sort_index方法，它将返回一个已排序的新对象
>>> obj=Series(range(4),index=['a','b','c','d']) >>> obj.sort_index() a 0 b 1 c 2 d 3 dtype: int64
对于DataFrame，可以根据任意一个轴上的索引进行排序：
>>> frame=DataFrame(np.arange(8).reshape((2,4)),index=['three','one'],columns=['d','a','b','c']) >>> frame d a b c three 0 1 2 3 one 4 5 6 7 >>> frame.sort_index() d a b c one 4 5 6 7 three 0 1 2 3 >>> frame.sort_index(axis=1) #指定轴进行排序 a b c d three 1 2 3 0 one 5 6 7 4
Series若要进行按值排序，则可使用order方法，ascending参数可指定升降序
>>> obj a 0 b 1 c 2 d 3 dtype: int64 >>> obj.order(ascending=False) d 3 c 2 b 1 a 0 dtype: int64 #排序时任何缺失值都会被排到Series的末尾
DataFrame的按值排序可以根据一个或多个列中的值进行排序，将一个或多个列名传递给by参数即可
>>> frame=DataFrame({'a':[4,7,-3,2],'b':[0,1,0,1]})
>>> frame
a b
0 4 0
1 7 1
2 -3 0
3 2 1
>>> frame.sort_index(by='b')
a b
0 4 0
2 -3 0
1 7 1
3 2 1
>>> frame.sort_index(by=['a','b']) #多列排序传入列名的列表即可
a b
2 -3 0
3 2 1
0 4 0
1 7 1
排名跟排序关系密切，且会增加一个排名值(排名从1开始),给对应值排名，输出索引和名次，
>>> obj=Series([7,-5,7,4,2,0,4]) >>> obj 0 7 1 -5 2 7 3 4 4 2 5 0 6 4 dtype: int64 >>> obj.rank() 0 6.5 1 1.0 2 6.5 3 4.5 4 3.0 5 2.0 6 4.5 dtype: float64
rank函数也可以根据值在数据中出现的位置顺序进行排名，相同值顺序在前排名高，也可以进行降序排名：
>>> obj.rank(method='first') 0 6 1 1 2 7 3 4 4 3 5 2 6 5 dtype: float64 >>> obj.rank(ascending=False,method='max') 0 2 1 7 2 2 3 4 4 5 5 6 6 4 dtype: float64
带有重复值的轴索引
pandas中轴索引非必须为唯一，对于带有重复值的索引，数据选取的行为将不同，如果某个索引对应多个值，则返回一个Series，而对应单个值，则返回一个标量值，对于Series与DataFrame类型数据皆为如此。（DataFrame单索引返回Series，重复索引返回DataFrame类型）
>>> obj=Series(range(5),index=['a','a','b','b','c']) >>> obj.index.is_unique False >>> obj['a'] a 0 a 1 dtype: int64 >>> obj['c'] 4
汇总和计算统计描述
idxmin，idxmax返回的是间接统计，cumsum返回累计统计
>>> df=DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index=['a','b','c','d'],columns=['one','two']) >>> df one two a 1.40 NaN b 7.10 -4.5 c NaN NaN d 0.75 -1.3 >>> df.idxmax() one b two d dtype: object >>> df.cumsum() one two a 1.40 NaN b 8.50 -4.5 c NaN NaN d 9.25 -5.8
describe方法一次性产生多个汇总统计，对于非数值型数据，describe方法会产生另外一种汇总统计：
>>> df.describe() one two count 3.000000 2.000000 mean 3.083333 -2.900000 std 3.493685 2.262742 min 0.750000 -4.500000 25% 1.075000 -3.700000 50% 1.400000 -2.900000 75% 4.250000 -2.100000 max 7.100000 -1.300000 >>> obj=Series(['a','a','b','c']*4) >>> obj.describe() count 16 unique 3 top a freq 8 dtype: object
| 描述和汇总统计方法介绍 | |
| 参数 | 说明 |
| count | 非NA值的数量 |
| describe | 针对Series或各DataFrame列计算汇总统计 |
| min，max | 计算最大值和最小值 |
| argmin，argmax | 计算能够获取到最大最小值的索引位置（整数） |
| idxmin，idxmax | 计算能够获取到最大最小值的索引值 |
| sum | 值的求和 |
| mean | 均值 |
| mad | 根据平均值计算绝对离差 |
| var | 方差 |
| std | 标准差 |
| diff | 计算一阶差分 |
| cumsum | 样本值的累积和 |
唯一值，值计数以及成员资格
一类方法可以从一维Series中抽取信息：
>>> obj=Series(['c','a','d','a','a','b','b','c']) >>> uniques=obj.unique() >>> uniques array(['c', 'a', 'd', 'b'], dtype=object) #unique方法得到Series中唯一值数组 >>> obj.value_counts() a 3 b 2 c 2 d 1 dtype: int64 #value_counts用于计算Series中各值出现的频率 >>> mask=obj.isin(['b','c']) >>> mask 0 True 1 False 2 False 3 False 4 False 5 True 6 True 7 True dtype: bool >>> obj[mask] 0 c 5 b 6 b 7 c dtype: object #isin用于判断矢量化的成员资格，可用于选取Series列中的数据子集
处理缺失数据
pandas使用浮点值NaN表示浮点数和非浮点数组中的缺失数据，它只是一个便于被检测出来的标记，pandas对象上所有的描述统计都排除了缺失数据
>>> from pandas import Series,DataFrame >>> import numpy as np >>> string_data=Series(['aardvark','artichoke',np.nan,'avocado']) >>> string_data 0 aardvark 1 artichoke 2 NaN 3 avocado dtype: object >>> sring_data.isnull() >>> string_data.isnull() 0 False 1 False 2 True 3 False dtype: bool #python内置的None属性会被当作NA处理 >>> string_data[0]=None >>> string_data.isnull() 0 True 1 False 2 True 3 False dtype: bool
滤除缺失数据的方法有很多，手工是一种，但dropna是比较实用的一种方法，dropna返回一个仅含非空数据和索引值的Series。
>>> data=Series([1,np.nan,3.5,np.nan,7]) >>> data 0 1.0 1 NaN 2 3.5 3 NaN 4 7.0 dtype: float64 >>> data.dropna() 0 1.0 2 3.5 4 7.0 dtype: float64 #也可以通过布尔型索引达到这个目的 >>> data[data.notnull()] 0 1.0 2 3.5 4 7.0 dtype: float64
对于DataFrame对象，dropnan默认丢弃任何含有缺失值的行：
>>> data=DataFrame([[1,6.5,3],[1,np.nan,np.nan],[np.nan,np.nan,np.nan],[np.nan,6.5,3]]) >>> data 0 1 2 0 1 6.5 3 1 1 NaN NaN 2 NaN NaN NaN 3 NaN 6.5 3 >>> cleaned=data.dropna() >>> cleaned 0 1 2 0 1 6.5 3 #传入how='all',则只丢弃全为na的那些行 >>> data.dropna(how='all') 0 1 2 0 1 6.5 3 1 1 NaN NaN 3 NaN 6.5 3 #如要丢弃列，则传入axis=1即可
当你不想丢弃过滤缺失数据时，可以通过其他方法填补缺失数据，大多数情况下fillna是最主要的函数，通过一个常数调用就会将缺失值替换为想要的常数值
>>> df.ix[:4,1]=np.nan >>> df 0 1 2 0 0.644651 NaN -0.858760 1 -0.093238 NaN -0.179058 2 1.547357 NaN -0.160275 3 -0.159654 NaN -0.898084 4 -0.987568 NaN -0.128100 5 -0.950301 -0.882556 0.155634 6 1.090057 -0.312113 -1.098901 >>> df.fillna(0) 0 1 2 0 0.644651 0.000000 -0.858760 1 -0.093238 0.000000 -0.179058 2 1.547357 0.000000 -0.160275 3 -0.159654 0.000000 -0.898084 4 -0.987568 0.000000 -0.128100 5 -0.950301 -0.882556 0.155634 6 1.090057 -0.312113 -1.098901 #通过字典调用fillna，可实现不同列填充不同的值 >>> df.fillna({1:0.5,3:-1}) 0 1 2 0 0.644651 0.500000 -0.858760 1 -0.093238 0.500000 -0.179058 2 1.547357 0.500000 -0.160275 3 -0.159654 0.500000 -0.898084 4 -0.987568 0.500000 -0.128100 5 -0.950301 -0.882556 0.155634 6 1.090057 -0.312113 -1.098901
层次化索引
层次化索引是pandas的一项重要功能，它使你能在一个轴上拥有多个索引级别，可以低纬度的形式处理高维度数据：
>>> 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 a 1 0.671419 2 -0.645337 3 -0.681691 b 1 -1.096300 2 -1.017407 3 -0.299791 c 1 1.268928 2 1.051565 d 2 0.821926 3 -0.628511 dtype: float64 >>> data['b'] 1 -1.096300 2 -1.017407 3 -0.299791 dtype: float64 #数据甚至可以在内层选取 >>> data[:,2] a -0.645337 b -1.017407 c 1.051565 d 0.821926 dtype: float64
层次化索引在数据重塑和基于分组的操作中，扮有重要角色，对于DataFrame，每条轴都可以有分层索引，可以轻松选取列分组
#Series可以通过unstack安排到一个DataFrame中去 >>> data.unstack() 1 2 3 a 0.671419 -0.645337 -0.681691 b -1.096300 -1.017407 -0.299791 c 1.268928 1.051565 NaN d NaN 0.821926 -0.628511 >>> data.unstack().stack() a 1 0.671419 2 -0.645337 3 -0.681691 b 1 -1.096300 2 -1.017407 3 -0.299791 c 1 1.268928 2 1.051565 d 2 0.821926 3 -0.628511 dtype: float64
重排分级顺序与根据级别进行汇总统计
有时需要重新调整某条轴上各级别的顺序或者根据指定级别上的值进行重新排序，swaplevel可以接受两个级别编号或名称，并返回一个互换了级别的新对象。值汇总统计时，使用level参数可以指定在某条轴上求和的级别。
>>> 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 ohio colorado green red green a 1 0 1 2 2 3 4 5 b 1 6 7 8 2 9 10 11 >>> frame.index.names=['key1','key2'] >>> frame.columns.names=['state','color'] >>> frame.swaplevel('key1','key2') state ohio colorado color green red green key2 key1 1 a 0 1 2 2 a 3 4 5 1 b 6 7 8 2 b 9 10 11
#在key2上进行归纳求和 >>> frame.sum(level='key2') state ohio colorado color green red green key2 1 6 8 10 2 12 14 16 >>> frame.sum(level='color',axis=1) color green red key1 key2 a 1 2 1 2 8 4 b 1 14 7 2 20 10
使用DataFrame的列
DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的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'])
>>> frame2
a b
c d
one 0 0 7
1 1 6
2 2 5
two 0 3 4
1 4 3
2 5 2
3 6 1
