当前位置： >>
Python Pandas基础教程
作者：& &发布时间： 17:25:59& &浏览次数：6046
pandas 是基于 Numpy 构建的含有更高级数据结构和工具的数据分析包
pandas 是基于 Numpy 构建的含有更高级数据结构和工具的数据分析包
类似于 Numpy 的核心是 ndarray，pandas 也是围绕着 Series 和 DataFrame 两个核心数据结构展开的 。Series 和 DataFrame 分别对应于一维的序列和二维的表结构。pandas 约定俗成的导入方法如下：
&from pandas import Series,DataFrameimport pandas as pd&
Series 可以看做一个定长的有序字典。基本任意的一维数据都可以用来构造 Series 对象：
&&&& s = Series([1,2,3.0,'abc'])&&& s0
abcdtype: object&
虽然 dtype:object 可以包含多种基本数据类型，但总感觉会影响性能的样子，最好还是保持单纯的 dtype。
Series 对象包含两个主要的属性：index 和 values，分别为上例中左右两列。因为传给构造器的是一个列表，所以 index 的值是从 0 起递增的整数，如果传入的是一个类字典的键值对结构，就会生成 index-value 对应的 Series；或者在初始化的时候以关键字参数显式指定一个 index 对象：
&&&& s = Series(data=[1,3,5,7],index = ['a','b','x','y'])&&& sa
7dtype: int64&&& s.indexIndex(['a', 'b', 'x', 'y'], dtype='object')&&& s.valuesarray([1, 3, 5, 7], dtype=int64)&
Series 对象的元素会严格依照给出的 index 构建，这意味着：如果 data 参数是有键值对的，那么只有 index 中含有的键会被使用；以及如果 data 中缺少响应的键，即使给出 NaN 值，这个键也会被添加。
注意 Series 的 index 和 values 的元素之间虽然存在对应关系，但这与字典的映射不同。index 和 values 实际仍为互相独立的 ndarray 数组，因此 Series 对象的性能完全 ok。
Series 这种使用键值对的数据结构最大的好处在于，Series 间进行算术运算时，index 会自动对齐。
另外，Series 对象和它的 index 都含有一个 name 属性：
&&&& s.name = 'a_series'&&& s.index.name = 'the_index'&&& sthe_indexa
7Name: a_series, dtype: int64&
DataFrame 是一个表格型的数据结构，它含有一组有序的列（类似于 index），每列可以是不同的值类型（不像 ndarray 只能有一个 dtype）。基本上可以把 DataFrame 看成是共享同一个 index 的 Series 的集合。
DataFrame 的构造方法与 Series 类似，只不过可以同时接受多条一维数据源，每一条都会成为单独的一列：
&&&& data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],'year':[02,],'pop':[1.5,1.7,3.6,2.4,2.9]}&&& df = DataFrame(data)&&& dfpop
2002&[5 rows x 3 columns]&
虽然参数 data 看起来是个字典，但字典的键并非充当 DataFrame 的 index 的角色，而是 Series 的 &name& 属性。这里生成的 index 仍是 &01234&。
较完整的 DataFrame 构造器参数为：DataFrame(data=None,index=None,coloumns=None)，columns 即 &name&：
&&&& df = DataFrame(data,index=['one','two','three','four','five'],columns=['year','state','pop','debt'])&&& dfyear
pop debtone
NaN&[5 rows x 4 columns]&
同样缺失值由 NaN 补上。看一下 index、columns 和 索引的类型：
&&&& df.indexIndex(['one', 'two', 'three', 'four', 'five'], dtype='object')&&& df.columnsIndex(['year', 'state', 'pop', 'debt'], dtype='object')&&& type(df['debt'])&class 'pandas.core.series.Series'&&
DataFrame 面向行和面向列的操作基本是平衡的，任意抽出一列都是 Series。
查找某个值在数组中的索引，类似于 Python 内建的 list.index(value) 方法。可以通过布尔索引来实现。比如我们想在一个 Series 中寻找到 &c&：
&&&& ser = Series(list('abcdefg'))&&& ser[ser='c']2
cdtype: object&
Series 中还有一对 ser.idxmax() 和 ser.idxmin() 方法，可以返回数组中最大（小）值的索引值，或者 .argmin() 和 .argmax() 返回索引位置。当然这两类方法也是可以通过上面这种 ser[ser=ser.max()] 来替代实现的。
数组的 index 属性时不可变的，因此所谓修改索引，其实操作的是一个使用了新索引的新数组，并继承旧数据。
obj.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False) 方法接受一个新索引（key）并返回一个新数组。这个 key 的值可以是序列类型，也可以是调用者的一个列名，即将某一列设为新数组的索引。
&&&& indexed_df = df.set_index(['A', 'B'])&&& indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])&&& indexed_df3 = df.set_index('column1')&
Series 对象的重新索引通过其 .reindex(index=None,**kwargs) 方法实现。**kwargs 中常用的参数有俩：method=None,fill_value=np.NaN：
&ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])&&& a = ['a','b','c','d','e']&&& ser.reindex(a)a
NaNdtype: float64&&& ser.reindex(a,fill_value=0)a
0.0dtype: float64&&& ser.reindex(a,method='ffill')a
4.5dtype: float64&&& ser.reindex(a,fill_value=0,method='ffill')a
4.5dtype: float64&
.reindex() 方法会返回一个新对象，其 index 严格遵循给出的参数，method:{'backfill', 'bfill', 'pad', 'ffill', None} 参数用于指定插值（填充）方式，当没有给出时，自动用 fill_value 填充，默认为 NaN（ffill = pad，bfill = back fill，分别指插值时向前还是向后取值）
DataFrame 对象的重新索引方法为：.reindex(index=None,columns=None,**kwargs)。仅比 Series 多了一个可选的 columns 参数，用于给列索引。用法与上例类似，只不过插值方法 method 参数只能应用于行，即轴 0。
&&&& state = ['Texas','Utha','California']&&& df.reindex(columns=state,method='ffill')Texas
Californiaa
8&[3 rows x 3 columns]&&& df.reindex(index=['a','b','c','d'],columns=state,method='ffill')Texas
Californiaa
8&[4 rows x 3 columns]&
不过 fill_value 依然对有效。聪明的小伙伴可能已经想到了，可不可以通过 df.T.reindex(index,method='**').T 这样的方式来实现在列上的插值呢，答案是可行的。另外要注意，使用 reindex(index,method='**') 的时候，index 必须是单调的，否则就会引发一个 ValueError: Must be monotonic for forward fill，比如上例中的最后一次调用，如果使用 index=['a','b','d','c'] 的话就不行。
删除指定轴上的项
即删除 Series 的元素或 DataFrame 的某一行（列）的意思，通过对象的 .drop(labels, axis=0) 方法：
3.6dtype: float64&&& dfOhio
Californiaa
8&[3 rows x 3 columns]&&& ser.drop('c')d
-5.3dtype: float64&&& df.drop('a')Ohio
Californiac
8&[2 rows x 3 columns]&&& df.drop(['Ohio','Texas'],axis=1)Californiaa
8&[3 rows x 1 columns]&
.drop() 返回的是一个新对象，元对象不会被改变。
索引和切片
就像 Numpy，pandas 也支持通过 obj[::] 的方式进行索引和切片，以及通过布尔型数组进行过滤。
不过须要注意，因为 pandas 对象的 index 不限于整数，所以当使用非整数作为切片索引时，它是末端包含的。
3.6dtype: float64&&& bar0
3.6dtype: float64&&& foo[:2]a
7.2dtype: float64&&& bar[:2]0
7.2dtype: float64&&& foo[:'c']a
-5.3dtype: float64&
这里 foo 和 bar 只有 index 不同&&bar 的 index 是整数序列。可见当使用整数索引切片时，结果与 Python 列表或 Numpy 的默认状况相同；换成 'c' 这样的字符串索引时，结果就包含了这个边界元素。
另外一个特别之处在于 DataFrame 对象的索引方式，因为他有两个轴向（双重索引）。
可以这么理解：DataFrame 对象的标准切片语法为：.ix[::,::]。ix 对象可以接受两套切片，分别为行（axis=0）和列（axis=1）的方向：
&&&& dfOhio
Californiaa
8&[3 rows x 3 columns]&&& df.ix[:2,:2]Ohio
4&[2 rows x 2 columns]&&& df.ix['a','Ohio']0&
而不使用 ix ，直接切的情况就特殊了：
索引时，选取的是列
切片时，选取的是行
这看起来有点不合逻辑，但作者解释说 &这种语法设定来源于实践&，我们信他。
&&&& df['Ohio']a
6Name: Ohio, dtype: int32&&& df[:'c']Ohio
Californiaa
5&[2 rows x 3 columns]&&& df[:2]Ohio
Californiaa
5&[2 rows x 3 columns]&
还有一种特殊情况是：假如有这样一个索引 index([2,4,5]) ，当我们使用 ser[2] 索引的时候，到底会被解释为第一个索引还是第三个索引呢？
答案是第一个索引，即当你的数组 index 是整数类型的时候，你使用整数索引，都会被自动解释为基于标签的索引，而不是基于位置的索引。要想消除这种歧义，可以使用
.loc[label] 这是严格基于标签的索引
.iloc[inte] 这是严格基于整数位置的索引
.ix[] 更像是这两种严格方式的智能整合版。
使用布尔型数组的情况，注意行与列的不同切法（列切法的 : 不能省）：
&&&& df['Texas']&=4a
TrueName: Texas, dtype: bool&&& df[df['Texas']&=4]Ohio
Californiac
8&[2 rows x 3 columns]&&& df.ix[:,df.ix['c']&=4]Texas
Californiaa
8&[3 rows x 2 columns]&
算术运算和数据对齐
pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。
&&&& foo = Series({'a':1,'b':2})&&& fooa
2dtype: int64&&& bar = Series({'b':3,'d':4})&&& barb
4dtype: int64&&& foo + bara
NaNdtype: float64&
DataFrame 的对齐操作会同时发生在行和列上。
当不希望在运算结果中出现 NA 值时，可以使用前面 reindex 中提到过 fill_value 参数，不过为了传递这个参数，就需要使用对象的方法，而不是操作符：df1.add(df2,fill_value=0)。其他算术方法还有：sub(), div(), mul()。
Series 和 DataFrame 之间的算术运算涉及广播，暂时先不讲。
函数应用和映射
Numpy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象。
当希望将函数应用到 DataFrame 对象的某一行或列时，可以使用 .apply(func, axis=0, args=(), **kwds) 方法。
&f = lambda x:x.max()-x.min()&&& dfOhio
Californiaa
8&[3 rows x 3 columns]&&& df.apply(f)Ohio
6California
6dtype: int64&&& df.apply(f,axis=1)a
2dtype: int64&
排序和排名
Series 的 sort_index(ascending=True) 方法可以对 index 进行排序操作，ascending 参数用于控制升序或降序，默认为升序。
若要按值对 Series 进行排序，当使用 .order(na_last=True, ascending=True, kind='mergesort') 方法，任何缺失值默认都会被放到 Series 的末尾。
在 DataFrame 上，.sort_index(axis=0, by=None, ascending=True) 方法多了一个轴向的选择参数与一个 by 参数，by 参数的作用是针对某一（些）列进行排序（不能对行使用 by 参数）：
&&&& df.sort_index(by='Ohio')Ohio
Californiaa
8&[3 rows x 3 columns]&&& df.sort_index(by=['California','Texas'])Ohio
Californiaa
8&[3 rows x 3 columns]&&& df.sort_index(axis=1)California
7&[3 rows x 3 columns]&
排名（Series.rank(method='average', ascending=True)）的作用与排序的不同之处在于，他会把对象的 values 替换成名次（从 1 到 n）。这时唯一的问题在于如何处理平级项，方法里的 method 参数就是起这个作用的，他有四个值可选：average, min, max, first。
&&&& ser=Series([3,2,0,3],index=list('abcd'))&&& sera
3dtype: int64&&& ser.rank()a
3.5dtype: float64&&& ser.rank(method='min')a
3dtype: float64&&& ser.rank(method='max')a
4dtype: float64&&& ser.rank(method='first')a
4dtype: float64&
注意在 ser[0]=ser[3] 这对平级项上，不同 method 参数表现出的不同名次。
DataFrame 的 .rank(axis=0, method='average', ascending=True) 方法多了个 axis 参数，可选择按行或列分别进行排名，暂时好像没有针对全部元素的排名方法。
pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值，或从 DataFrame 的行或列中提取一个 Series。
比如 DataFrame.mean(axis=0,skipna=True) 方法，当数据集中存在 NA 值时，这些值会被简单跳过，除非整个切片（行或列）全是 NA，如果不想这样，则可以通过 skipna=False 来禁用此功能：
&&&& dfone
7.10 -4.5c
0.75 -1.3&[4 rows x 2 columns]&&& df.mean()one
3.083333two
-2.900000dtype: float64&&& df.mean(axis=1)a
-0.275dtype: float64&&& df.mean(axis=1,skipna=False)a
-0.275dtype: float64&
其他常用的统计方法有：
########################
*******************************************
非 NA 值的数量
针对 Series 或 DF 的列计算汇总统计
最小值和最大值
argmin , argmax
最小值和最大值的索引位置（整数）
idxmin , idxmax
最小值和最大值的索引值
样本分位数（0 到 1）
根据均值计算平均绝对离差
样本值的偏度（三阶矩）
样本值的峰度（四阶矩）
样本值的累计和
cummin , cummax
样本值的累计最大值和累计最小值
样本值的累计积
计算一阶差分（对时间序列很有用）
pct_change
计算百分数变化
协方差与相关系数
Series 有两个方法可以计算协方差与相关系数，方法的主要参数都是另一个 Series。DataFrame 的这两个方法会对列进行两两运算，并返回一个 len(columns) 大小的方阵：
.corr(other, method='pearson', min_periods=1) 相关系数，默认皮尔森
.cov(other, min_periods=None) 协方差
min_periods 参数为样本量的下限，低于此值的不进行运算。
列与 Index 间的转换
DataFrame 的 .set_index(keys, drop=True, append=False, verify_integrity=False) 方法会将其一个或多个列转换为行索引，并返回一个新对象。默认 drop=True 表示转换后会删除那些已经变成行索引的列。另一个 .reset_index() 方法的作用正相反，会把已经层次化的索引转换回列里面。
&&&& df = DataFrame(np.arange(8).reshape(4,2),columns=['a','b'])&&& dfa
7&[4 rows x 2 columns]&&& df2 = df.set_index('a')&&& df2ba0
7&[4 rows x 1 columns]&&& df2.reset_index()a
7&[4 rows x 2 columns]&
处理缺失数据
pandas 中 NA 的主要表现为 np.nan，另外 Python 内建的 None 也会被当做 NA 处理。
处理 NA 的方法有四种：dropna , fillna , isnull , notnull 。
is(not)null
这一对方法对对象做元素级应用，然后返回一个布尔型数组，一般可用于布尔型索引。
对于一个 Series，dropna 返回一个仅含非空数据和索引值的 Series。
问题在于对 DataFrame 的处理方式，因为一旦 drop 的话，至少要丢掉一行（列）。这里的解决方式与前面类似，还是通过一个额外的参数：dropna(axis=0, how='any', thresh=None) ，how 参数可选的值为 any 或者 all。all 仅在切片元素全为 NA 时才抛弃该行(列)。另外一个有趣的参数是 thresh，该参数的类型为整数，它的作用是，比如 thresh=3，会在一行中至少有 3 个非 NA 值时将其保留。
fillna(value=None, method=None, axis=0) 中的 value 参数除了基本类型外，还可以使用字典，这样可以实现对不同的列填充不同的值。method 的用法与前面 .reindex() 方法相同，这里不再赘述。
inplace 参数
前面有个点一直没讲，结果整篇示例写下来发现还挺重要的。就是 Series 和 DataFrame 对象的方法中，凡是会对数组作出修改并返回一个新数组的，往往都有一个 replace=False 的可选参数。如果手动设定为 True，那么原数组就可以被替换。
层次化索引
层次化索引（hierarchical indexing）是 pandas 的一项重要功能，它允许你在一个轴上拥有多个索引级别。换句话说，一个使用了层次化的索引的二维数组，可以存储和处理三维以上的数据。
&&&& hdf = DataFrame(np.arange(8).reshape(4,2),index=[['sh','sh','sz','sz'],['600000','600001','000001','000002']],columns=['open','close'])&&& hdfopen
closesh 600000
3sz 000001
7&[4 rows x 2 columns]&&& hdf.indexMultiIndex(levels=[['sh', 'sz'], ['000001', '000002', '600000', '600001']],labels=[[0, 0, 1, 1], [2, 3, 0, 1]])&
上例中原本 sh 和 sz 已经是第三维的索引了，但使用层次化索引后，可以将整个数据集控制在二维表结构中。这对于数据重塑和基于分组的操作（如生成透视表）比较重要。
索引或层次化索引对象（Index 与 MultiIndex）都有一个 names 属性，可以用来给索引层次命名，以便索引和增加直观性。对 names 属性的操作可以直接通过 obj.index.names=[] 的形式来实现。
pandas 提供了一组标准的时间序列处理工具和数据算法
数据类型及操作
Python 标准库的 datetime
datetime 模块中的 datetime、 time、 calendar 等类都可以用来存储时间类型以及进行一些转换和运算操作。
&&&& from datetime import datetime&&& now = datetime.now()&&& nowdatetime.datetime(, 15, 56, 19, 313193)&&& delta = datetime()-datetime()&&& deltadatetime.timedelta(1)&&& now + deltadatetime.datetime(, 15, 56, 19, 313193)&
datetime 对象间的减法运算会得到一个 timedelta 对象，表示一个时间段。
datetime 对象与它所保存的字符串格式时间戳之间可以互相转换。str() 函数是可用的，但更推荐 datetime.strptime() 方法。这个方法可以实现双向转换。
&&&& str(now)' 15:56:19.313193'&&& now.strftime('%Y-%m-%d')''&&& datetime.strptime('','%Y-%m-%d')datetime.datetime(, 0, 0)&
如 %Y 这种格式代表了某种具体的意义，但用着很麻烦。因此可以使用一个名为 dateutil 第三方包的 parser.parse() 函数实现自动转义，它几乎可以解析任何格式（这也可能会带来麻烦）。
&&&& from dateutil.parser import parse&&& parse('01-02-2010',dayfirst=True)datetime.datetime(, 0, 0)&&& parse('01-02-2010')datetime.datetime(, 0, 0)&&& parse('55')datetime.datetime(, 0, 0)&
pandas 的 TimeStamp
pandas 最基本的时间日期对象是一个从 Series 派生出来的子类 TimeStamp，这个对象与 datetime 对象保有高度兼容性，可通过 pd.to_datetime() 函数转换。（一般是从 datetime 转换为 Timestamp）
&&&& pd.to_datetime(now)Timestamp(' 15:56:19.313193', tz=None)&&& pd.to_datetime(np.nan)NaT&
pandas 的时间序列
pandas 最基本的时间序列类型就是以时间戳（TimeStamp）为 index 元素的 Series 类型。
&&&& dates = [datetime(),datetime(),datetime()]&&& ts = Series(np.random.randn(3),index=dates)&&& ts
-0.154522dtype: float64&&& type(ts)&class 'pandas.core.series.Series'&&&& ts.index&class 'pandas.tseries.index.DatetimeIndex'&[, ..., ]Length: 3, Freq: None, Timezone: None&&& ts.index[0]Timestamp(' 00:00:00', tz=None)&
时间序列之间的算术运算会自动按时间对齐。
索引、选取、子集构造
时间序列只是 index 比较特殊的 Series ，因此一般的索引操作对时间序列依然有效。其特别之处在于对时间序列索引的操作优化。如使用各种字符串进行索引：
&&&& ts['']0.97266&&& ts['']0.97266&&& ts['01/01/2011']0.97266&
对于较长的序列，还可以只传入 &年& 或 &年月& 选取切片：
0.111869dtype: float64&&& ts['2012']
0.111869dtype: float64&&& ts['':'2012-12']
0.111869dtype: float64&
除了这种字符串切片方式外，还有一种实例方法可用：ts.truncate(after='')。
值得注意的是，切片时使用的字符串时间戳并不必存在于 index 之中，如 ts.truncate(before='3055') 也是合法的。
日期的范围、频率以及移动
pandas 中的时间序列一般被默认为不规则的，即没有固定的频率。但出于分析的需要，我们可以通过插值的方式将序列转换为具有固定频率的格式。一种快捷方式是使用 .resample(rule) 方法：
0.222958dtype: float64&&& ts.resample('D')
0.222958Freq: D, dtype: float64&
生成日期范围
pd.date_range() 可用于生成指定长度的 DatetimeIndex。参数可以是起始结束日期，或单给一个日期，加一个时间段参数。日期是包含的。
&&&& pd.date_range('','')&class 'pandas.tseries.index.DatetimeIndex'&[, ..., ]Length: 10, Freq: D, Timezone: None&&& pd.date_range(start='',periods=10)&class 'pandas.tseries.index.DatetimeIndex'&[, ..., ]Length: 10, Freq: D, Timezone: None&&& pd.date_range(end='',periods=10)&class 'pandas.tseries.index.DatetimeIndex'&[, ..., ]Length: 10, Freq: D, Timezone: None&
默认情况下，date_range 会按天计算时间点。这可以通过 freq 参数进行更改，如 &BM& 代表 bussiness end of month。
&&&& pd.date_range('','',freq='BM')&class 'pandas.tseries.index.DatetimeIndex'&[, ..., ]Length: 5, Freq: BM, Timezone: None&
频率和日期偏移量
pandas 中的频率是由一个基础频率和一个乘数组成的。基础频率通常以一个字符串别名表示，如上例中的 &BM&。对于每个基础频率，都有一个被称为日期偏移量（date offset）的对象与之对应。可以通过实例化日期偏移量来创建某种频率：
&&&& Hour()&Hour&&&& Hour(2)&2 * Hours&&&& Hour(1) + Minute(30)&90 * Minutes&&
但一般来说不必这么麻烦，使用前面提过的字符串别名来创建频率就可以了：
&&&& pd.date_range('00:00','12:00',freq='1h20min')&class 'pandas.tseries.index.DatetimeIndex'&[ 00:00:00, ...,
12:00:00]Length: 10, Freq: 80T, Timezone: None&
可用的别名，可以通过 help() 或 文档来查询，这里就不写了。
移动（超前和滞后）数据
移动（shifting）指的是沿着时间轴将数据前移或后移。Series 和 DataFrame 都有一个 .shift() 方法用于执行单纯的移动操作，index 维持不变：
0.222958dtype: float64&&& ts.shift(2)
0.586695dtype: float64&&& ts.shift(-2)
NaNdtype: float64&
上例中因为移动操作产生了 NA 值，另一种移动方法是移动 index，而保持数据不变。这种移动方法需要额外提供一个 freq 参数来指定移动的频率：
&&&& ts.shift(2,freq='D')
0.222958dtype: float64&&& ts.shift(2,freq='3D')
0.222958dtype: float64&
时期及其算术运算
本节使用的时期（period）概念不同于前面的时间戳（timestamp），指的是一个时间段。但在使用上并没有太多不同，pd.Period 类的构造函数仍需要一个时间戳，以及一个 freq 参数。freq 用于指明该 period 的长度，时间戳则说明该 period 在公园时间轴上的位置。
&&&& p = pd.Period(2010,freq='M')&&& pPeriod('2010-01', 'M')&&& p + 2Period('2010-03', 'M')&
上例中我给 period 的构造器传了一个 &年& 单位的时间戳和一个 &Month& 的 freq，pandas 便自动把 2010 解释为了 2010-01。
period_range 函数可用于创建规则的时间范围：
&&&& pd.period_range('2010-01','2010-05',freq='M')&class 'pandas.tseries.period.PeriodIndex'&freq: M[2010-01, ..., 2010-05]length: 5&
PeriodIndex 类保存了一组 period，它可以在任何 pandas 数据结构中被用作轴索引：
&&&& Series(np.random.randn(5),index=pd.period_range('201001','201005',freq='M'))2010-01
0.7559612010-02
-1.0744922010-03
-0.3797192010-04
0.1536622010-05
-0.291157Freq: M, dtype: float64&
时期的频率转换
Period 和 PeriodIndex 对象都可以通过其 .asfreq(freq, method=None, how=None) 方法被转换成别的频率。
&&&& p = pd.Period('2007',freq='A-DEC')&&& p.asfreq('M',how='start')Period('2007-01', 'M')&&& p.asfreq('M',how='end')Period('2007-12', 'M')&&& ts = Series(np.random.randn(1),index=[p])&&& ts2007
-0.112347Freq: A-DEC, dtype: float64&&& ts.asfreq('M',how='start')2007-01
-0.112347Freq: M, dtype: float64&
时间戳与时期间相互转换
以时间戳和以时期为 index 的 Series 和 DataFrame 都有一对 .to_period() 和 to_timestamp(how='start') 方法用于互相转换 index 的类型。因为从 period 到 timestamp 的转换涉及到一个取端值的问题，所以需要一个额外的 how 参数，默认为 'start'：
&&&& ts = Series(np.random.randn(5),index=pd.period_range('201001','201005',freq='M'))&&& ts2010-01
-0.3121602010-02
0.9626522010-03
-0.9594782010-04
1.2402362010-05
-0.916218Freq: M, dtype: float64&&& ts.to_timestamp()
-0.916218Freq: MS, dtype: float64&&& ts.to_timestamp(how='end')
-0.916218Freq: M, dtype: float64&&& ts.to_timestamp().to_period() 00:00:00.000
-0.312160 00:00:00.000
0.962652 00:00:00.000
-0.959478 00:00:00.000
1.240236 00:00:00.000
-0.916218Freq: L, dtype: float64&&& ts.to_timestamp().to_period('M')2010-01
-0.3121602010-02
0.9626522010-03
-0.9594782010-04
1.2402362010-05
-0.916218Freq: M, dtype: float64&
重采样及频率转换
重采样（resampling）指的是将时间序列从一个频率转换到另一个频率的过程。pandas 对象都含有一个 .resample(freq, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start', kind=None, loffset=None, limit=None, base=0) 方法用于实现这个过程。
本篇最前面曾用 resample 规整化过时间序列。当时进行的是插值操作，因为原索引的频率与给出的 freq 参数相同。resample 方法更多的应用场合是 freq 发生改变的时候，这时操作就分为升采样（upsampling）和降采样（downsampling）两种。具体的区别都体现在参数里。
&&&& ts2010-01
-0.3121602010-02
0.9626522010-03
-0.9594782010-04
1.2402362010-05
-0.916218Freq: M, dtype: float64&&& ts.resample('D',fill_method='ffill')#升采样
-0.31216...
-0.916218Freq: D, Length: 151&&& ts.resample('A-JAN',how='sum')#降采样2010
-0.3121602011
0.327191Freq: A-JAN, dtype: float64&
上一篇：&&&&下一篇：
交换链接&&
Copyright &2017 &&
All Right Reserved.
Powered by
版权所有 &