pandas笔记-ch05:pandas入门
ch05
pandas入门¶
In [1]:
from pandas import Series, DataFrame
import pandas as pd
In [2]:
'以下不知道什么意思。'
%matplotlib inline
from __future__ import division
from numpy.random import randn
import numpy as np
import os
import matplotlib.pyplot as plt
np.random.seed(12345)
In [3]:
plt.rc('figure', figsize=(10, 6))
In [4]:
from pandas import Series, DataFrame
import pandas as pd
np.set_printoptions(precision=4)
In [9]:
%pwd
Out[9]:
pandas数据结构的介绍¶
Series¶
理解1：一维数组 + 索引值
理解2：定长有序字典
In [14]:
'Series = 一维数组 + 索引值'
obj = Series([4, 7, -5, 3])
obj
Out[14]:
In [15]:
'访问 Series 的 values 和 index'
obj.values
Out[15]:
In [16]:
obj.index
Out[16]:
In [18]:
'自定义 index'
obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
obj2
Out[18]:
In [19]:
obj2.index
Out[19]:
In [21]:
'通过索引取值'
obj2['a']
Out[21]:
In [22]:
'索引赋值'
obj2['d'] = 6
obj2[['c', 'a', 'd']]
Out[22]:
In [27]:
'一般的数学运算会保留 index 与 values 的联系'
obj2[obj2 > 0]
Out[27]:
In [28]:
obj2 * 2
Out[28]:
In [29]:
'注意，这里是 np.exp 方法接受 pd 参数'
np.exp(obj2)
Out[29]:
In [30]:
'把Series看成定长有序的 字典'
'b' in obj2
Out[30]:
In [31]:
'e' in obj2
Out[31]:
In [32]:
'通过字典创建Series'
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = Series(sdata)
obj3
Out[32]:
In [34]:
'字典中的 键 不在 index中则返回 NaN'
states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = Series(sdata, index=states)
obj4
Out[34]:
In [37]:
'isnull notnull 检测 NaN 值'
pd.isnull(obj4) # 顶层方法检测
Out[37]:
In [38]:
pd.notnull(obj4)
Out[38]:
In [40]:
obj4.isnull() #实例化方法检测
Out[40]:
In [41]:
'Series在算术运算中自动对齐不同索引的数据'
obj3
Out[41]:
In [42]:
obj4
Out[42]:
In [43]:
obj3 + obj4
Out[43]:
In [44]:
'Series本身及其索引都有一个name属性，该属性与pandas的其他关键功能关系密切'
obj4.name = 'population'
obj4.index.name = 'state'
obj4
Out[44]:
In [46]:
'通过赋值修改索引'
obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
obj
Out[46]:
DataFrame¶
In [50]:
'由等长列表或数组构成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)
frame #自动添加索引，列有序排序
Out[50]:
In [52]:
'指定顺序对列进行排序'
DataFrame(data, columns=['year', 'state', 'pop'])
Out[52]:
In [53]:
'索引值与 产生NaN的行为'
frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
frame2
Out[53]:
In [54]:
frame2.columns
Out[54]:
In [55]:
'通过字典获取Series'
frame2['state']
Out[55]:
In [56]:
'通过属性获取Series'
frame2.year
Out[56]:
In [57]:
'通过 framer.ix: 获取Series'
frame2.ix['three']
Out[57]:
In [58]:
'赋值修改DataFrame'
frame2['debt'] = 16.5
frame2
Out[58]:
In [59]:
frame2['debt'] = np.arange(5.)
frame2
Out[59]:
In [61]:
'列表或数组赋值给DataFrame列，长度必须对应相同， 如果赋值是一个Series，则通过索引匹配赋值'
val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
frame2['debt'] = val
frame2
Out[61]:
In [65]:
'创建新列：给不在column中的元素赋值'
frame2['eastern'] = frame2.state == 'Ohio'
frame2
Out[65]:
In [66]:
'删除列'
del frame2['eastern']
frame2.columns
Out[66]:
In [5]:
'嵌套字典赋值DataFrame，外层键为列，内层键为行索引'
pop = {'Nevada': {2001: 2.4, 2002: 2.9},
'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [6]:
frame3 = DataFrame(pop)
frame3
Out[6]:
In [7]:
'转置'
frame3.T
Out[7]:
In [8]:
'默认下，内层字典的键会被合并、排序以形成最终的索引。如果显式指定了索引，则不会这样'
DataFrame(pop, index=[2001, 2002, 2003])
Out[8]:
In [9]:
'由Series组成的字典差不多也是一样的用法'
pdata = {'Ohio': frame3['Ohio'][:-1],
'Nevada': frame3['Nevada'][:2]}
DataFrame(pdata)
Out[9]:
表5-1：可以输入给DataFrame构造器的数据¶
二维ndarray 数据矩阵，还可以传入行标和列标 由数组、列标或元组组成的字典 每个序列会变成DataFrame的一列。所有序列的长度必须相同 NumPy的结构化/记录数组 类似于‘由数组组成的字典’ 有Series组成的字典 每个Series会成为一列。如果没有显示指定索引，则各Series的索引会被合并成结果的行索引 由字典组成的字典 各内层字典会成为一列。键会被合并成结果的行索引，个‘由Series组成的字典’的情况一样 字典或Series的列表 各项将成为DataFrame的一行。字典键或Series索引的并集将成为DataFrame的列标 由列表或元组组成的列表 类似于‘二维ndarray’ 另一个DataFrame 该DataFrame的索引将被沿用，除非显式指定了其他索引 Numpy的MaskedArray 类似于‘二维ndarray’的情况，只是掩码值在结果DataFrame会变成NA/缺失值
In [10]:
'指定DataFrame的index 和 columns 的 name'
frame3.index.name = 'year'; frame3.columns.name = 'state'
frame3
Out[10]:
In [73]:
'values属性以二维ndarray的形式返回'
frame3.values
Out[73]:
In [74]:
'各列数据类型不同的DataFrame的values情况'
frame2.values
Out[74]:
索引对象¶
In [76]:
obj = Series(range(3), index=['a', 'b', 'c'])
index = obj.index
index
Out[76]:
In [77]:
index[1:]
Out[77]:
In [80]:
'index对象不可修改，以保证index对象在多个数据结构之间安全共享'
index[1] = 'd'
In [81]:
index = pd.Index(np.arange(3))
obj2 = Series([1.5, -2.5, 0], index=index)
obj2.index is index
Out[81]:
表5-2：pandas中主要的index对象¶
Iindex 最泛化的index对象，将轴标签表示为一个由Python对象组成的Numpy数组 Int64Index 针对整数的特殊index MultiIndex ‘层次化’索引对象，表示单个轴上的多层索引。可以看做由单元组组成的数组 DatetimeIndex 存储纳秒级的时间戳（用Numpy的datetime64类型表示） PeriodIndex 针对Period数据（时间间隔）的特殊Index
In [82]:
'除了长得像数组，index的功能也类似一个固定大小的集合'
frame3
Out[82]:
In [83]:
'Ohio' in frame3.columns
Out[83]:
In [84]:
2003 in frame3.index
Out[84]:
表5-3 index的属性和方法：¶
append 连接另一个Index对象，产生一个新的Index diff 计算差集，并得到一个Index intersection 计算交集 union 计算并集 isin 计算一个指示各值是否都包含在参数合中的布尔型数组 delete 删除索引i处的元素，并得到新的Index drop 删除传入的值，并得到新的Index insert 将元素插入到索引i处，并得到新的Index is_monotonic 当各元素均大于等于前一个元素时，返回True is_unique 当Index没有重复时，返回True unique 计算Index中唯一值的数组
基本功能¶
重新索引¶
In [4]:
obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
obj
Out[4]:
In [5]:
'reindex重建索引(改变索引的排序顺序)，不存在对应索引值则为NaN'
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
obj2
Out[5]:
In [7]:
'reindex(fill_value),NaN的填充值'
obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)
Out[7]:
In [9]:
'插值:method='
obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
obj3.reindex(range(6), method='ffill')
Out[9]:
表5-4：reindex的插值（method）选项¶
ffill或pad 前后填充（或搬运）值 bfill或backfill 向后填充（或搬运）值
In [11]:
'reindex既可以修改行索引，也可以修改列'
frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'],
columns=['Ohio', 'Texas', 'California'])
frame
Out[11]:
In [12]:
frame2 = frame.reindex(['a', 'b', 'c', 'd']) #默认行索引
frame2
Out[12]:
In [13]:
states = ['Texas', 'Utah', 'California'] #列 重新排序
frame.reindex(columns=states)
Out[13]:
In [14]:
frame.reindex(index=['a', 'b', 'c', 'd'], method='ffill',
columns=states) #行索引，列同时排序
Out[14]:
In [16]:
'ix 的标签索引功能，重新索引使用起来看起来更简单'
frame.ix[['a', 'b', 'c', 'd'], states]
Out[16]:
表5-5reindex函数的参数：¶
index 用作索引的新序列。既可以是Index实例，也可以是其他序列型的Python数据结构。Index会被完全使用，就像没有任何复制一样 method 插值（填充）方式，具体参数请参见表5-4 fill_value 在重新索引的过程中，需要引入缺失值时使用的替代值 limit 前向或后向填充时的最大填充量 level 在MultiIndex的指定级别上匹配简单索引，否则选取其子集 copy 默认为True，无论如何都复制；如果为False，则新旧相等就不复制
丢弃指定轴上的项¶
本质：先复制，在处理，返回处理后的结果。
In [17]:
obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
new_obj
Out[17]:
In [18]:
obj.drop(['d', 'c'])
Out[18]:
In [19]:
data = DataFrame(np.arange(16).reshape((4, 4)),
index=['Ohio', 'Colorado', 'Utah', 'New York'],
columns=['one', 'two', 'three', 'four'])
In [20]:
data.drop(['Colorado', 'Ohio'])
Out[20]:
In [21]:
data.drop('two', axis=1)
Out[21]:
In [22]:
data.drop(['two', 'four'], axis=1)
Out[22]:
索引，选取和过滤¶
In [26]:
'Series索引的使用方法与array类似，只不过索引值还可以是其他形式'
obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj['b']
Out[26]:
In [27]:
obj[1]
Out[27]:
In [28]:
obj[2:4]
Out[28]:
In [29]:
obj[['b', 'a', 'd']]
Out[29]:
In [30]:
obj[[1, 3]]
Out[30]:
In [31]:
obj[obj < 2]
Out[31]:
In [32]:
'注意这里的索引值的切片与Python的切片的不同：'
obj['b':'c']
Out[32]:
In [33]:
obj['b':'c'] = 5
obj
Out[33]:
In [37]:
'DataFrame索引'
data = DataFrame(np.arange(16).reshape((4, 4)),
index=['Ohio', 'Colorado', 'Utah', 'New York'],
columns=['one', 'two', 'three', 'four'])
data
Out[37]:
In [38]:
data['two']
Out[38]:
In [39]:
data[['three', 'one']]
Out[39]:
In [40]:
data[:2]
Out[40]:
In [41]:
data[data['three'] > 5]
Out[41]:
In [42]:
data < 5
Out[42]:
In [43]:
data[data < 5] = 0
In [44]:
data
Out[44]:
In [45]:
'ix 数值以及行列标签的（切片+索引）'
data.ix['Colorado', ['two', 'three']]
Out[45]:
In [46]:
data.ix[['Colorado', 'Utah'], [3, 0, 1]]
Out[46]:
In [47]:
data.ix[2]
Out[47]:
In [48]:
data.ix[:'Utah', 'two']
Out[48]:
In [49]:
data.ix[data.three > 5, :3]
Out[49]:
In [51]:
data.ix[2:4,1:3]
Out[51]:
表5-6：DataFrame的索引选项¶
obj[val] 选取DataFrame的单个列或一组列。在一些特殊情况下会比较便利：布尔型数组（过滤行）、切片（行切片）、布尔型DataFrame（根据条件设置值） obj.ix[val] 选取DataFrame的单个行或一组行 obj.ix[:,val] 选取单个列或列子集 obj.ix[val1,val2] 同时选取行和列 reindex方法 将一个或多个轴匹配到新索引 xs方法 根据标签选取单行或单列，并返回一个Series icol,irow方法 根据整数位置选取单列或单行，并返回一个Series get_value，set_value方法 根据行标签和列标签选取单个值
算术运算和数据对齐¶
In [55]:
'针对Series'
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'])
In [56]:
s1
Out[56]:
In [57]:
s2
Out[57]:
In [58]:
s1 + s2
Out[58]:
In [61]:
'针对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
Out[61]:
In [62]:
df2
Out[62]:
In [63]:
df1 + df2
Out[63]:
在算术方法中填充值¶
In [64]:
df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
df1
Out[64]:
In [65]:
df2
Out[65]:
In [66]:
df1 + df2
Out[66]:
In [67]:
'算术方法中NaN的填充（这里只有一方有NaN，所以只填充一方）'
df1.add(df2, fill_value=0)
Out[67]:
In [68]:
'reindex中的NaN填充'
df1.reindex(columns=df2.columns, fill_value=0)
Out[68]:
表5-7：灵活的算术方法¶
add 用于加法（+）的方法 sub - div / mul *
DataFrame 和 Series 之间的运算¶
In [69]:
'Numpy中的广播运算'
arr = np.arange(12.).reshape((3, 4))
arr
Out[69]:
In [70]:
arr[0]
Out[70]:
In [71]:
'这种运算称为广播(broadcasting)'
arr - arr[0]
Out[71]:
In [72]:
'Pandas中的广播运算：'
frame = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.ix[0]
frame
Out[72]:
In [73]:
series
Out[73]:
In [74]:
'默认情况下，DataFrame和Series之间的运算会将Series的索引匹配到DataFrame的列，然后沿着行向下广播'
frame - series
Out[74]:
In [75]:
'缺省值处理'
series2 = Series(range(3), index=['b', 'e', 'f'])
frame + series2
Out[75]:
In [76]:
'行匹配，列广播的方法：'
series3 = frame['d']
frame
Out[76]:
In [77]:
series3
Out[77]:
In [78]:
'传入的轴是希望匹配的轴'
frame.sub(series3, axis=0)
Out[78]:
函数应用和映射¶
In [79]:
'Numpy的ufuncs也可以用于操作pandas对象'
frame = DataFrame(np.random.randn(4, 3), columns=list('bde'),
index=['Utah', 'Ohio', 'Texas', 'Oregon'])
In [80]:
frame
Out[80]:
In [81]:
np.abs(frame)
Out[81]:
In [82]:
'DataFrame与函数的联合'
f = lambda x: x.max() - x.min()
In [83]:
frame.apply(f)
Out[83]:
In [84]:
frame.apply(f, axis=1) #自定义运用的轴
Out[84]:
In [85]:
def f(x):
return Series([x.min(), x.max()], index=['min', 'max'])
frame.apply(f)
#注：许多DataFrame的内置函数如sum,mean等功能可以直接使用，而不需要使用apply多此一举
Out[85]:
In [86]:
'元素级的函数：applymap'
format = lambda x: '%.2f' % x
frame.applymap(format)
Out[86]:
In [87]:
frame['e'].map(format)
Out[87]:
排序和排名¶
In [88]:
'sort_index按 行 或 列 索引排序'
obj = Series(range(4), index=['d', 'a', 'b', 'c'])
obj.sort_index()
Out[88]:
In [89]:
frame = DataFrame(np.arange(8).reshape((2, 4)), index=['three', 'one'],
columns=['d', 'a', 'b', 'c'])
frame.sort_index()
Out[89]:
In [90]:
frame.sort_index(axis=1)
Out[90]:
In [91]:
frame.sort_index(axis=1, ascending=False)
Out[91]:
In [92]:
'order按值进行排序(用法过时，应该为sort_values)'
obj = Series([4, 7, -3, 2])
obj.order()
Out[92]:
In [95]:
'sort_values按值进行排序'
obj = Series([4, 7, -3, 2])
obj.sort_values()
Out[95]:
In [96]:
obj = Series([4, np.nan, 7, np.nan, -3, 2])
obj.sort_values() #NaN排在末尾
Out[96]:
In [97]:
frame = DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame
Out[97]:
In [98]:
'依据某一列（或者多列）的值进行排序：传递 by= 选项 （已经过时：应修改为sort_values(by=)）'
frame.sort_index(by='b')
Out[98]:
In [100]:
'正确做法：'
frame.sort_values(by='b')
Out[100]:
In [102]:
'多列排序'
frame.sort_values(by=['a', 'b'])
Out[102]:
不懂？？？？？
In [103]:
'默认：method="average" 在相等分组中，为各个值分配平均排名'
obj = Series([7, -5, 7, 4, 2, 0, 4])
obj.rank()
Out[103]:
In [104]:
'method="first" 按值在原始数据中的出现顺序分配排名'
obj.rank(method='first')
Out[104]:
In [106]:
'ascending=False: 降序 '
'method="max": 使用整个分组的最大排名'
obj.rank(ascending=False, method='max')
Out[106]:
In [107]:
frame = DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
'c': [-2, 5, 8, -2.5]})
frame
Out[107]:
In [108]:
frame.rank(axis=1)
Out[108]:
表5-8：排名时用于破坏平级关系的method=选项¶
'average' 默认：在相等分组中，为各个值分配平均排名 'min' 使用整个分组的最小排名 'max' 使用整个分组的最大排名 'first' 按值在原始数据中的出现顺序分配排名
带有重复值的轴索引¶
In [109]:
obj = Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
obj #obj带有重复索引值
Out[109]:
In [110]:
obj.index.is_unique #判断索引值是否唯一
Out[110]:
In [111]:
'重复索引的数据选取行为：'
obj['a']
Out[111]:
In [112]:
obj['c']
Out[112]:
In [113]:
'DataFrame的重复索引情况：'
df = DataFrame(np.random.randn(4, 3), index=['a', 'a', 'b', 'b'])
df
Out[113]:
In [114]:
df.ix['b']
Out[114]:
汇总和计算描述统计¶
In [116]:
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
Out[116]:
In [117]:
df.sum()
Out[117]:
In [118]:
df.sum(axis=1)
Out[118]:
In [119]:
df.mean(axis=1, skipna=False)
Out[119]:
表5-9：约简方法的选项¶
axis= 约简的轴。DataFrame的行用0，列用1 skipna= 排除缺失值，默认值为True level= 如果轴是层次化索引的（即MultiIndex），则根据level分组约简
In [122]:
'其他情况：'
'idxmax反回间接统计：(到达最大值的索引)'
df.idxmax()
Out[122]:
In [123]:
'cumsum:累计型'
df.cumsum()
Out[123]:
In [124]:
'describe:描述型'
df.describe()
Out[124]:
In [125]:
'describe：非数值型的汇总方法：'
obj = Series(['a', 'a', 'b', 'c'] * 4)
obj.describe()
Out[125]:
表5-10：描述和汇总统计¶
count 非NA值的数量 describe 针对Series或各DataFrame列计算汇总统计 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 计算百分数变化
相关系数与协方差¶
x.corr() 与 x.cov()
x.corrwith()
In [135]:
import pandas_datareader.data as web
all_data = {}
for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOG']:
all_data[ticker] = web.get_data_yahoo(ticker)
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()})
In [136]:
'x.pct_change(): 计算百分数变化'
returns = price.pct_change()
returns.tail()
Out[136]:
In [137]:
'计算两个Series中的重叠的、非NA的、按索引对齐的值的相关系数'
returns.MSFT.corr(returns.IBM)
Out[137]:
In [138]:
'计算协方差'
returns.MSFT.cov(returns.IBM)
Out[138]:
In [139]:
'完整的相关系数矩阵'
returns.corr()
Out[139]:
In [140]:
'完整的相关系数协方差'
returns.cov()
Out[140]:
In [141]:
'returns.corrwith(): 返回相关系数的Series'
returns.corrwith(returns.IBM)
Out[141]:
In [142]:
'传入DataFrame则会计算按列名配对的相关系数。这里计算百分比变化与成交量的相关系数'
returns.corrwith(volume)
Out[142]:
唯一值，值计数以及成员资格¶
In [143]:
obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
In [144]:
uniques = obj.unique()
uniques
Out[144]:
In [145]:
'value_counts的实例化方法'
obj.value_counts()
Out[145]:
In [154]:
'注意obj.values与obj的不同：'
obj.values
Out[154]:
In [155]:
obj
Out[155]:
In [146]:
'value_counts的顶级pandas的方法'
pd.value_counts(obj.values, sort=False)
Out[146]:
In [147]:
'isin：成员资格测试'
mask = obj.isin(['b', 'c'])
mask
Out[147]:
In [148]:
obj[mask]
Out[148]:
表5-11：唯一值、值计数、成员资格方法¶
isin 计算一个表示‘Series各值是否包含于传入的值序列中’的布尔型数组 unique 计算Series中的唯一值数组，按发现的顺序返回 value_counts 返回一个Series，其索引为唯一值，其值为频率，按计数值降序排列
In [149]:
data = DataFrame({'Qu1': [1, 3, 4, 3, 4],
'Qu2': [2, 3, 1, 2, 3],
'Qu3': [1, 5, 2, 4, 4]})
data
Out[149]:
In [156]:
'pd.value_counts传递给DataFrame的apply函数：'
result = data.apply(pd.value_counts).fillna(0)
result
Out[156]:
处理缺失的数据¶
In [157]:
string_data = Series(['aardvark', 'artichoke', np.nan, 'avocado'])
string_data
Out[157]:
In [158]:
string_data.isnull()
Out[158]:
In [159]:
'None值被视为NaN值处理'
string_data[0] = None
string_data.isnull()
Out[159]:
表5-12：NA处理方法¶
dropna 根据各标签的值中是否存在缺失数据对轴标签进行过滤，可通过阔值调节对缺失值的容忍度 fillna 用指定值或插值方法（如ffill或bfill）填充缺失数据 isnull 返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值N/A,该对象的类型与源类型一样 notnull isnull的否定式
滤除缺失数据¶
x.dropna()
In [160]:
'对于一个Series，dropna返回一个仅含非空数据和索引值的Series'
from numpy import nan as NA
data = Series([1, NA, 3.5, NA, 7])
data.dropna()
Out[160]:
In [161]:
'也可通过布尔型索引过滤NA'
data[data.notnull()]
Out[161]:
In [164]:
'对于一个DataFrame,dropna默认丢弃任何含有缺失值的行'
data = DataFrame([[1., 6.5, 3.], [1., NA, NA],
[NA, NA, NA], [NA, 6.5, 3.]])
cleaned = data.dropna()
data
Out[164]:
In [165]:
cleaned
Out[165]:
In [167]:
'x.dropna(how="all")： 将只丢弃全为NA的那些行'
data.dropna(how='all')
Out[167]:
In [168]:
data[4] = NA
data
Out[168]:
In [169]:
'传入axis=1，可以指定对列进行丢弃'
data.dropna(axis=1, how='all')
Out[169]:
In [172]:
'另一个滤除DataFrame行的问题设计时间序列数据。假设你只想留下一部分观测数据，可以用thresh参数实现此目的'
df = DataFrame(np.random.randn(7, 3))
df.ix[:4, 1] = NA; df.ix[:2, 2] = NA
df
Out[172]:
In [171]:
'x.dropna(thresh=n): 剔除非参数个数<n的行或者列'
df.dropna(thresh=3)
Out[171]:
In [173]:
df.dropna(thresh=2)
Out[173]:
In [174]:
df.dropna(thresh=1)
Out[174]:
填充缺失数据¶
fillna():默认返回新对象，传入inplace会修改原有对象
In [175]:
'一般性的用法'
df.fillna(0)
Out[175]:
In [176]:
'传入字典：对列(key)进行自定义填充(value)'
df.fillna({1: 0.5, 3: -1})
Out[176]:
In [177]:
'传入inplace会修改原对象'
_ = df.fillna(0, inplace=True)
df
Out[177]:
In [178]:
'对reindex有效的那些插值方法也可以用于fillna:'
df = DataFrame(np.random.randn(6, 3))
df.ix[2:, 1] = NA; df.ix[4:, 2] = NA
df
Out[178]:
In [179]:
df.fillna(method='ffill')
Out[179]:
In [180]:
df.fillna(method='ffill', limit=2)
Out[180]:
In [181]:
'利用fillna实现其他的功能：例，传入平均值'
data = Series([1., NA, 3.5, NA, 7])
data.fillna(data.mean())
Out[181]:
表5-13：fillna函数的参数¶
value 用于填充缺失值的标量值或字典对象 method 插值方式。如果函数调用时未指定其他参数的话，默认为‘ffill' axis 带填充的轴，默认axis=0 inplace 修改调用者对象而不产生副本 limit （对于前向和后向填充）可以连续填充的最大数量
层次化的索引¶
In [182]:
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
Out[182]:
In [184]:
data.index
Out[184]:
In [185]:
data['b']
Out[185]:
In [186]:
'注意DataFrame的索引值切片与Python的索引切片的区别：前者两端都包括，后者只包括前端'
data['b':'c']
Out[186]:
In [187]:
data.ix[['b', 'd']]
Out[187]:
In [188]:
'在内层中选取：'
data[:, 2]
Out[188]:
In [189]:
'unstack: stack(堆，这里指层次化索引数据)转化成DataFrame'
data.unstack()
Out[189]:
In [190]:
data.unstack().stack()
Out[190]:
In [191]:
'对于一个DataFrame，每条轴都有可以分层索引'
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
Out[191]:
In [192]:
'可以指定各层的名称：'
frame.index.names = ['key1', 'key2']
frame.columns.names = ['state', 'color']
frame
Out[192]:
In [193]:
frame['Ohio']
Out[193]:
重排分级顺序¶
In [194]:
'x.swaplevel():层次级别互换'
frame.swaplevel('key1', 'key2')
Out[194]:
In [195]:
'sortlevel:单层排序'
frame.sortlevel(1)
Out[195]:
In [196]:
frame.swaplevel(0, 1).sortlevel(0)
Out[196]:
根据级别汇总统计¶
其实利用了pandas的groupby功能
In [197]:
'sum: 对DataFrame分层求和：'
frame.sum(level='key2')
Out[197]:
In [198]:
frame.sum(level='color', axis=1)
Out[198]:
使用DataFrame的列¶
In [199]:
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]})
frame
Out[199]:
In [200]:
'set_index:将其中一个或者多个列转换为行索引，并移除转换的列'
frame2 = frame.set_index(['c', 'd'])
frame2
Out[200]:
In [201]:
'set_index(drop= ):列转换成索引，并保留列数据数据'
frame.set_index(['c', 'd'], drop=False)
Out[201]:
In [202]:
'reset_index:与set_index功能相反，还原后，层次化索引会被转换到列的里面'
frame2.reset_index()
Out[202]:
其他pandas话题¶
整数索引¶
In [207]:
ser = Series(np.arange(3.))
ser
Out[207]:
In [ ]:
'对于整数索引，下面会出错，因为Series的轴索引含有索引器，根据整数进行数据选取的操作将总是面向标签的。 -1 不在标签里面，所以下面会出错！'
#ser[-1] #error
In [212]:
'但是下面使用没问题，因为标签里面有 1 '
ser[1]
Out[212]:
In [215]:
'以上规则同样适用于用ix进行切片'
'注意标签切片与索引切片的不同：标签切片两端都包括，索引切片只包括端首'
ser.ix[:1]
Out[215]:
In [216]:
'对于非整数索引，则不存在这样的问题，因为此时根据整数选取数据实际是在进行切片操作'
ser2 = Series(np.arange(3.), index=['a', 'b', 'c'])
ser2[-1]
Out[216]:
总结：loc,at,ix,iloc,iat的区别：¶
loc和at传递标签参数，iloc和iat传递数值参数，用来索引和切片
loc和iloc可以返回一个区域或者一个值，但是at和iat只能返回固定值
ix既可以传递标签，也可以传递数值，只是传递数值的时候要遵守本节上面说的规则
他们都是pandas获取数据的内置方法。与传统的方法（直接[]）相比，更推荐这样操作
In [213]:
'如上所述：使用pandas的iloc或者iat方法会默认把传入的整数作为索引处理'
ser.iloc[-1]
Out[213]:
In [217]:
ser3 = Series(range(3), index=[-5, 1, 3])
ser3.iloc[2]
Out[217]:
In [221]:
frame = DataFrame(np.arange(6).reshape((3, 2)), index=[2, 0, 1])
frame
Out[221]:
In [218]:
frame.iloc[0]
Out[218]:
In [228]:
frame.iloc[0,:]
Out[228]:
面板数据¶
In [ ]:
import pandas_datareader.data as web
pdata = pd.Panel(dict((stk, web.get_data_yahoo(stk))
for stk in ['AAPL', 'GOOG', 'MSFT', 'DELL']))
In [237]:
pdata
Out[237]:
In [238]:
pdata = pdata.swapaxes('items', 'minor')
pdata['Adj Close']
Out[238]:
In [239]:
pdata.ix[:, '6/1/2012', :]
Out[239]:
In [240]:
'这里不用.ix也是一样的,两者实际中的性能一样。'
pdata[:, '6/1/2012', :]
Out[240]:
In [243]:
%timeit pdata[:, '6/1/2012', :]
In [244]:
%timeit pdata.ix[:, '6/1/2012', :]
In [245]:
pdata.ix['Adj Close', '5/22/2012':, :]
Out[245]:
In [246]:
'to_frame: 层叠式堆积DataFrame来显示部分Panel'
stacked = pdata.ix[:, '5/30/2012':, :].to_frame()
stacked
Out[246]:
In [247]:
'to_panel: to_frame的逆运算'
stacked.to_panel()
Out[247]:
In [ ]:
浙公网安备 33010602011771号