Python数据分析-时间序列（1）
Python数据分析-时间序列（1）
不管在哪个领域中（如金融学、经济学、生态学、神经科学、物理学等），时间序列 ( time series ）数据都是一种重要的结构化数据形式。在多个时间点观察或测量到的任何事务都可以形成一段时间序列。很多时间序列是固定频率的，也就是说，数据点是根据某种规律定期出现的（比如每 15 秒、每 5 分钟、每月出现一次）。时间序列也可以是不定期的。时间序列数据的意义取决于具体的应用场景，主要有以下几种：
时间戳（ timestamp ) ，特定的时刻。
固定时期（ period ) ，如 2017年1月或2010年全年。
时间间隔（interval ) ，由起始和结束时间戳表示。时期（ period ）可以被看做间隔 ( interval ）的特例。
实验或过程时间，每个时间点都是相对于特定起始时间的一个度量。例如，从放入烤箱时起，每秒钟饼干的直径。
本章主要讲解前3种时间序列。许多技术都可用于处理实验型时间序列，其索引可能是一个整数或浮点数（表示从实验开始算起已经过去的时间）。最简单也最常见的时间序列都是用时间戮进行索引的。
pandas 提供了一组标淮的时间序列处理工具和数据算法。因此，你可以高效处理非常大的时间序列，轻松地进行切片/切块、聚合、对定期／不定期的时间序列进行重采样等。可能你已经猜到了，这些工具中大部分都对金融和经济数据尤为有用，但你当然也可以用它们来分析服务器日志数据。
# 导入常用的包
import pandas as pd
import numpy as np
日期和时间数据类型工具
我们主要会用到datetime,time以及calendar模块。
In [2]: from datetime import datetime
now=datetime.now()
now
Out[2]: datetime.datetime(2019, 7, 2, 16, 47, 35, 130853)
In [3]: now.year,now.month,now.day
Out[3]: (2019, 7, 2)
[4]: delta=datetime(2011,1,7)-datetime(2008,6,24,8,15)
delta
Out[4]: datetime.timedelta(926, 56700)
In [5]: delta.days
Out[5]: 926
In [6]: delta.seconds
Out[6]: 56700
可以给datetime对象加上（或减去）一个或多个timedelta，这样会产生一个新对象：
In [11]: from datetime import timedelta
start = datetime(2011, 1, 7)
start + timedelta(12)
Out[11]: datetime.datetime(2011, 1, 19, 0, 0)
In [12]: start - 2 * timedelta(12)
Out[12]: datetime.datetime(2010, 12, 14, 0, 0)
| 类型 | 说明 |
|---|---|
| date | 以公历形式存储日历日期(年,月,日) |
| time | 将时间存储为时,分,秒,毫秒 |
| datetime | 存储日期和时间 |
| timedelta | 表示两个datetime值之间的差(日，秒，毫秒) |
字符串和datetime的相互转换
利用str或strftime方法（传入一个格式化字符串），datetime对象和pandas的 Timestamp对象（稍后就会介绍）可以被格式化为字符串：
In [14]: stamp=datetime(2011,1,3)
In [15]: str(stamp)
Out[15]: '2011-01-03 00:00:00'
In [16]: stamp.strftime("%Y-%m-%d")
Out[16]: '2011-01-03'
| 代码 | 说明 |
|---|---|
| % Y | 4 位数的年 |
| % y | 2 位数的年 |
| % m | 2 位数的月[01,12] |
| % d | 2 位数的日 [01,31] |
| % H | 时（24小时制）[00,23] |
| % l | 时（12小时制）[01,12] |
| % M | 2 位数的分[00,59] |
| % S | 秒[00,61]（秒60和61用于闰秒） |
| % w | 用整数表示的星期几[0(星期天),6] |
| % U | 每年的第几周[00,53]。星期天被认为是每周的第一天，每年第一个星期天之前的那几天被认为是‘第0周” |
| % W | 每年的第几周[00 , 53]。星期一被认为是每周的第一天．每年第一个星期一之前的那几天被认为是‘第0周” |
| %z | 以+HHMM或-HHMM表示的UTC时区偏移量，如果时区为naive，则返回空字符串 |
| %F | %Y-%m-%d 简写形式，例如 2012-4-15 |
| %D | %m/%d/%y 简写形式，例如 04/18/12 |
In [17]: value="2011-01-03"
In [18]: datetime.strptime(value,"%Y-%m-%d")
Out[18]: datetime.datetime(2011, 1, 3, 0, 0)
In [19]: datastrs=["7/6/2011","8/6/2011"]
In [21]: [datetime.strptime(x, '%m/%d/%Y') for x in datastrs]
Out[21]: [datetime.datetime(2011, 7, 6, 0, 0), datetime.datetime(2011, 8, 6, 0, 0)]
datetime.strptime是通过已知格式进行日期解析的最佳方式。但是每次都要编写格 式定义是很麻烦的事情，尤其是对于一些常见的日期格式。这种情况下，你可以用dateutil这个第三方包中的parser.parse方法（pandas中已经自动安装好了）：
In [22]: from dateutil.parser import parse
parse('2011-01-03')
Out[22]: datetime.datetime(2011, 1, 3, 0, 0)
dateutil可以解析几乎所有人类能够理解的日期表示形式：
In [23]: parse('Jan 31, 1997 10:45 PM')
Out[23]: datetime.datetime(1997, 1, 31, 22, 45)
在国际通用的格式中，日出现在月的前面很普遍，传入dayfirst=True即可解决这个 问题：```
In [24]: parse('6/12/2011', dayfirst=True)
Out[24]: datetime.datetime(2011, 12, 6, 0, 0)
pandas通常是用于处理成组日期的，不管这些日期是DataFrame的轴索引还是列。 to_datetime方法可以解析多种不同的日期表示形式。对标准日期格式（如ISO8601）的解析非常快：
In [25]: datastrs
Out[25]: ['7/6/2011', '8/6/2011']
In [27]: pd.to_datetime(datastrs)
Out[27]: DatetimeIndex(['2011-07-06', '2011-08-06'],
dtype='datetime64[ns]', freq=None)
它还可以处理缺失值（None、空字符串等）：
In [29]: idx = pd.to_datetime(datastrs + [None])
In [30]: idx
Out[30]: DatetimeIndex(['2011-07-06', '2011-08-06', 'NaT'],
dtype='datetime64[ns]', freq=None)
In [31]: idx[2]
Out[31]: NaT
In [32]: pd.isnull(idx)
Out[32]: array([False, False, True])
NaT（Not a Time）是pandas中时间戳数据的null值。
注意：dateutil.parser是一个实用但不完美的工具。比如说，它会把一些原本不 是日期的字符串认作是日期（比如"42"会被解析为2042年的今天）。
| 代码 | 说明 |
|---|---|
| %a | 星期几的简写 |
| %A | 星期几的全称 |
| %b | 月份的简写 |
| %B | 月份的全称 |
| %c | 完整的日期和时间,例如"Tue 01 May 2012 04:20:57 PM" |
| %p | 不同环境中的AM或pM |
| %x | 适合于当前环境的日期格式，例如，在美国," May l,2012”会产生"05/01/2012" |
| %X | 适合于当前环境的时间格式，例如"04:24:12 pM " |
时间序列基础
pandas最基本的时间序列类型就是以时间戳（通常以Python字符串或datatime对象 表示）为索引的Series：
In [37]: from datetime import datetime
dates = [datetime(2011, 1, 2),datetime(2011, 1, 5), datetime(2011, 1, 7),
datetime(2011, 1, 8), datetime(2011, 1, 10), datetime(2011, 1, 12)]
In [38]: ts = pd.Series(np.random.randn(6), index=dates)
In [39]: ts
Out[39]:
2011-01-02 -0.157756
2011-01-05 0.921180
2011-01-07 -0.695222
2011-01-08 1.056763
2011-01-10 -0.147111
2011-01-12 0.969202
dtype: float64
这些datetime对象实际上是被放在一个DatetimeIndex中的：
In [40]: type(ts)
Out[40]: pandas.core.series.Series
In [41]: ts.index
Out[41]: DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07',
'2011-01-08', '2011-01-10', '2011-01-12'], dtype='datetime64[ns]', freq=None)
没必要显示使用TimeSeries的构造函数，当创建一个带有DatetimeIndex的Series时，pandas就会知道该对象是一个时间序列。
跟其他Series一样，不同索引的时间序列之间的算术运算会自动按日期对齐：
In [44]: ts[::2]
Out[44]: 2011-01-02 -0.157756
2011-01-07 -0.695222
2011-01-10 -0.147111
dtype: float64
In [43]: ts+ts[::2]
Out[43]: 2011-01-02 -0.315512
2011-01-05 NaN
2011-01-07 -1.390444
2011-01-08 NaN
2011-01-10 -0.294222
2011-01-12 NaN
dtype: float64
pandas用NumPy的datetime64数据类型以纳秒形式存储时间戳：
In [45]: ts.index.dtype
Out[45]: dtype('DatetimeIndex中的各个标量值是pandas的Timestamp对象：
In [46]: stamp = ts.index[0]
In [48]: stamp
Out[48]: Timestamp('2011-01-02 00:00:00')
只要有需要，TimeStamp可以随时自动转换为datetime对象。此外，它还可以存储 频率信息（如果有的话），且知道如何执行时区转换以及其他操作。稍后将对此进 行详细讲解。
索引、选取、子集构造
由于TimeSeries是Series的一个子类，所以在索引以及数据选取方面他们的行为是一样的：
In [50]: stamp=ts.index[2]
In [51]: ts[stamp]
Out[51]: -0.6952218463574572
还有一种更为方便的用法：传入一个可以被解释为日期的字符串：
In [52]: ts['1/10/2011']
Out[52]: -0.14711095257082477
In [53]: ts['20110110']
Out[53]: -0.14711095257082477
对于较长的时间序列，只需传入“年”或“年月”即可轻松选取数据的切片：
In [56]: longer_ts = pd.Series(np.random.randn(1000),
index=pd.date_range('1/1/2000', periods=1000))
In [59]: longer_ts.head(10)
Out[59]: 2000-01-01 -0.038946
2000-01-02 0.224854
2000-01-03 0.852431
2000-01-04 -0.239002
2000-01-05 0.009658
2000-01-06 -0.298916
2000-01-07 2.563434
2000-01-08 0.378383
2000-01-09 -1.878040
2000-01-10 0.971717
Freq: D, dtype: float64
In [62]: longer_ts['2001'].head(10)
Out[62]: 2001-01-01 -1.610770
2001-01-02 0.619722
2001-01-03 0.041673
2001-01-04 0.088770
2001-01-05 -0.296027
2001-01-06 -0.342952
2001-01-07 -0.857835
2001-01-08 2.316226
2001-01-09 -1.681022
2001-01-10 0.852536
Freq: D, dtype: float64
这里，字符串“2001”被解释成年，并根据它选取时间区间。指定月也同样奏效：
In [63]: longer_ts['2001-05'].head()
Out[63]: 2001-05-01 -0.232010
2001-05-02 -0.769017
2001-05-03 0.565034
2001-05-04 0.383871
2001-05-05 -0.559395
Freq: D, dtype: float64
datetime对象也可以进行切片,通过日期进行切片的方式只对规则Series有效
In [64]: ts[datetime(2011, 1, 7):]
Out[64]: 2011-01-07 -0.695222
2011-01-08 1.056763
2011-01-10 -0.147111
2011-01-12 0.969202
dtype: float64
由于大部分时间序列数据都是按照时间先后排序的，因此你也可以用不存在于该时 间序列中的时间戳对其进行切片（即范围查询）：
In [65]: ts
Out[65]: 2011-01-02 -0.157756
2011-01-05 0.921180
2011-01-07 -0.695222
2011-01-08 1.056763
2011-01-10 -0.147111
2011-01-12 0.969202
dtype: float64
In [66]: ts['1/6/2011':'1/11/2011']
Out[66]: 2011-01-07 -0.695222
2011-01-08 1.056763
2011-01-10 -0.147111
dtype: float64
跟之前一样，你可以传入字符串日期、datetime或Timestamp。
注意，这样切片所 产生的是原时间序列的视图，跟NumPy数组的切片运算是一样的。 这意味着，没有数据被复制，对切片进行修改会反映到原始数据上。
此外，还有一个等价的实例方法也可以截取两个日期之间TimeSeries：
In [67]: ts.truncate(after='1/9/2011')
Out[67]: 2011-01-02 -0.157756
2011-01-05 0.921180
2011-01-07 -0.695222
2011-01-08 1.056763
dtype: float64
面这些操作对DataFrame也有效。例如，对DataFrame的行进行索引：
In [69]: dates = pd.date_range('1/1/2000', periods=100, freq='W-WED')
long_df = pd.DataFrame(np.random.randn(100, 4), index=dates,
columns=['Colorado', 'Texas', 'New York', 'Ohio'])In [71]: long_df.head()
Out[71]:
Colorado Texas New York Ohio
2000-01-05 1.560928 0.700287 -0.071332 -0.054938
2000-01-12 -0.758858 0.781727 0.410518 0.436076
2000-01-19 0.426602 -1.347247 -0.743251 -2.156083
2000-01-26 0.790530 -1.983819 -0.064161 -1.724807
2000-02-02 0.459608 -0.166151 -0.069839 -2.505114
In [72]: long_df.loc['5-2001']
Out[72]:
Colorado Texas New York Ohio
2001-05-02 -0.828038 0.388279 -1.161440 -0.163981
2001-05-09 -0.020725 -0.014960 0.146535 1.178431
2001-05-16 0.649418 -0.071721 1.200370 0.303326
2001-05-23 0.494012 -0.362802 0.869887 1.422389
2001-05-30 -0.078416 -1.260776 -0.725508 0.539561
带有重复索引的时间序列在
某些应用场景中，可能会存在多个观测数据落在同一个时间点上的情况。下面就 是一个例子：
In [77]: dates = pd.DatetimeIndex(['1/1/2000','1/2/2000','1/2/2000','
1/2/2000', '1/3/2000'])
In [78]: dates
Out[78]: DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-02',
'2000-01-02',
'2000-01-03'],dtype='datetime64[ns]', freq=None)
In [79]: dup_ts = pd.Series(np.arange(5), index=dates)
In [80]: dup_ts
Out[80]: 2000-01-01 0
2000-01-02 1
2000-01-02 2
2000-01-02 3
2000-01-03 4
dtype: int32
通过检查索引的is_unique属性，我们就可以知道它是不是唯一的：
In [81]: dup_ts.index.is_unique
Out[81]: False
对这个时间序列进行索引，要么产生标量值，要么产生切片，具体要看所选的时间 点是否重复：
In [82]: dup_ts['1/3/2000'] # not duplicated
Out[82]: 4
In [83]: dup_ts['1/2/2000'] # duplicated
Out[83]: 2000-01-02 1
2000-01-02 2
2000-01-02 3
dtype: int32
假设你想要对具有非唯一时间戳的数据进行聚合。一个办法是使用groupby，并传 入level=0：
In [88]: grouped = dup_ts.groupby(level=0)
In [89]: grouped.mean()
Out[89]: 2000-01-01 0
2000-01-02 2
2000-01-03 4
dtype: int32
In [90]: grouped.count()
Out[90]: 2000-01-01 1
2000-01-02 3
2000-01-03 1
日期的范围、频率以及移动
pandas中的原生时间序列一般被认为是不规则的，也就是说，它们没有固定的频 率。对于大部分应用程序而言，这是无所谓的。但是，它常常需要以某种相对固定
的频率进行分析，比如每日、每月、每15分钟等（这样自然会在时间序列中引入缺 失值）。幸运的是，pandas有一整套标准时间序列频率以及用于重采样、频率推
断、生成固定频率日期范围的工具。例如，我们可以将之前那个时间序列转换为一 个具有固定频率（每日）的时间序列，只需调用resample即可：
In [91]: ts
Out[91]: 2011-01-02 -0.157756
2011-01-05 0.921180
2011-01-07 -0.695222
2011-01-08 1.056763
2011-01-10 -0.147111
2011-01-12 0.969202
dtype: float64
In [94]: ts.resample('D')
Out[94]: DatetimeIndexResampler [freq=, axis=0, closed=left, label=left,
convention=start, base=0]
字符串“D”是每天的意思。
频率的转换（或重采样）是一个比较大的主题，稍后将专门用一节来进行讨论。这里，我将告诉你如何使用基本的频率和它的倍数。
生成日期范围
虽然我之前用的时候没有明说，但你可能已经猜到pandas.date_range可用于根据 指定的频率生成指定长度的DatetimeIndex：
In [95]: index = pd.date_range('2012-04-01', '2012-06-01')
index
Out[95]: DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
'2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
'2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
'2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
'2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20',
'2012-04-21', '2012-04-22', '2012-04-23', '2012-04-24',
'2012-04-25', '2012-04-26', '2012-04-27', '2012-04-28',
'2012-04-29', '2012-04-30', '2012-05-01', '2012-05-02',
'2012-05-03', '2012-05-04', '2012-05-05', '2012-05-06',
'2012-05-07', '2012-05-08', '2012-05-09', '2012-05-10',
'2012-05-11', '2012-05-12', '2012-05-13', '2012-05-14',
'2012-05-15', '2012-05-16', '2012-05-17', '2012-05-18',
'2012-05-19', '2012-05-20', '2012-05-21', '2012-05-22',
'2012-05-23', '2012-05-24', '2012-05-25', '2012-05-26',
'2012-05-27', '2012-05-28', '2012-05-29', '2012-05-30',
'2012-05-31', '2012-06-01'],
dtype='datetime64[ns]', freq='D')
默认情况下，date_range会产生按天计算的时间点。如果只传入起始或结束日期， 那就还得传入一个表示一段时间的数字：
In [96]: pd.date_range(start='2012-04-01', periods=20)
Out[96]: DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
'2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
'2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
'2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
'2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20'],
dtype='datetime64[ns]', freq='D')
In [97]: pd.date_range(end='2012-06-01', periods=20)
Out[97]: DatetimeIndex(['2012-05-13', '2012-05-14', '2012-05-15', '2012-05-16',
'2012-05-17', '2012-05-18', '2012-05-19', '2012-05-20',
'2012-05-21', '2012-05-22', '2012-05-23', '2012-05-24',
'2012-05-25', '2012-05-26', '2012-05-27', '2012-05-28',
'2012-05-29', '2012-05-30', '2012-05-31', '2012-06-01'],
dtype='datetime64[ns]', freq='D')
起始和结束日期定义了日期索引的严格边界。例如，如果你想要生成一个由每月最 后一个工作日组成的日期索引，可以传入"BM"频率（表示business end of
month），这样就只会包含时间间隔内（或刚好在边界上的）符合频率 要求的日期：
In [98]: pd.date_range('2000-01-01', '2000-12-01', freq='BM')
Out[98]: DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-28',
'2000-05-31', '2000-06-30', '2000-07-31', '2000-08-31',
'2000-09-29', '2000-10-31', '2000-11-30'],
dtype='datetime64[ns]', freq='BM')
date_range默认会保留起始和结束时间戳的时间信息（如果有的话）：
In [99]: pd.date_range('2012-05-02 12:56:31', periods=5)
Out[99]: DatetimeIndex(['2012-05-02 12:56:31', '2012-05-03 12:56:31',
'2012-05-04 12:56:31', '2012-05-05 12:56:31',
'2012-05-06 12:56:31'],
dtype='datetime64[ns]', freq='D')
有时，虽然起始和结束日期带有时间信息，但你希望产生一组被规范化 （normalize）到午夜的时间戳。normalize选项即可实现该功能：
In [101]: pd.date_range('2012-05-02 12:56:31', periods=5, normalize=True)
Out[101]: DatetimeIndex(['2012-05-02', '2012-05-03', '2012-05-04', '2012-05-05',
'2012-05-06'],
dtype='datetime64[ns]', freq='D')
频率和日期偏移量
pandas中的频率是由一个基础频率（base frequency）和一个乘数组成的。基础频 率通常以一个字符串别名表示，比如"M"表示每月，"H"表示每小时。对于每个基
础 频率，都有一个被称为日期偏移量（date offset）的对象与之对应。例如，按小时 计算的频率可以用Hour类表示：
In [102]: from pandas.tseries.offsets import Hour, Minute
In [103]: hour = Hour()
In [104]: hour
Out[104]:
传入一个整数即可定义偏移量的倍数：
In [106]: four_hours = Hour(4)
In [107]: four_hours
Out[107]: <4 * Hours>
一般来说，无需明确创建这样的对象，只需使用诸如"H"或"4H"这样的字符串别名 即可。在基础频率前面放上一个整数即可创建倍数：
In [109]: pd.date_range('2000-01-01', '2000-01-03 23:59', freq='4 h')
Out[109]: DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 04:00:00',
'2000-01-01 08:00:00', '2000-01-01 12:00:00',
'2000-01-01 16:00:00', '2000-01-01 20:00:00',
'2000-01-02 00:00:00', '2000-01-02 04:00:00',
'2000-01-02 08:00:00', '2000-01-02 12:00:00',
'2000-01-02 16:00:00', '2000-01-02 20:00:00',
'2000-01-03 00:00:00', '2000-01-03 04:00:00',
'2000-01-03 08:00:00', '2000-01-03 12:00:00',
'2000-01-03 16:00:00', '2000-01-03 20:00:00'],
dtype='datetime64[ns]', freq='4H')
大部分偏移量对象都可通过加法进行连接：
n [110]: Hour(2) + Minute(30)
Out[110]: <150 * Minutes>
同理，你也可以传入频率字符串（如"2h30min"），这种字符串可以被高效地解析为等效的表达式：
In [111]: pd.date_range('2000-01-01', periods=10, freq='1h30min')
Out[111]: DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 01:30:00',
'2000-01-01 03:00:00', '2000-01-01 04:30:00',
'2000-01-01 06:00:00', '2000-01-01 07:30:00',
'2000-01-01 09:00:00', '2000-01-01 10:30:00',
'2000-01-01 12:00:00', '2000-01-01 13:30:00'],
dtype='datetime64[ns]', freq='90T')
有些频率所描述的时间点并不是均匀分隔的。例如，“M”（日历月末）和"BM"（每 月最后一个工作日）就取决于每月的天数，对于后者，还要考虑月末是不是周末。
由于没有更好的术语，我将这些称为锚点偏移量（anchored offset）。
下面列出了pandas中的频率代码和日期偏移量类。 笔记：用户可以根据实际需求自定义一些频率类以便提供pandas所没有的日期 逻辑
| 别名 | 偏移量类型 | 说明 |
|---|---|---|
| D | Day | 每日历日 |
| B | BusinessDay | 每工作日 |
| H | Hour | 每小时 |
| T或min | Minute | 每分 |
| S | Second | 每秒 |
| L或ms | Milli | 每毫秒（即每千分之一秒) |
| U | Micro | 每微秒（即每百万分之一秒 |
| M | MonthEnd | 每月最后一个日历日 |
| BM | BusinessMonthEnd | 每月最后一个工作日 |
| MS | MonthBegin | 每月第一个日历日 |
| BMS | BusinessMonthBegin | 每月第一个工作日 |
| W-MON 、W-TUE… | Week | 从指定的星期几（MON、TUE、WED 、THU、FRI 、SAT、SUN）开始算起，每周 |
| WOM-1MON、WOM-2MON… | WeekOfMonth | 产生每月第一,第二,第三或第四周的星期几。例如，WOM-3FRI表示每月第3个星期五 |
| Q-JAN 、Q-FEB … | QuarterEnd | 对于以指定月份(JAN 、FEB 、 MAR 、 APR , MAY 、 JUN , JUL 、 AUG 、 SEP 、 OCT 、 NOV 、 DEC ）结束的年度，每季度最后一月的最后一个日历日 |
| BQ-JAN、 BQ-FES … | BusinessQuarterEnd | 对于以指定月份结束的年度，每季度最后一月的最后一个工作日 |
| QS-JAN、QS-FEB … | QuarterBegin | 对于以指定月份结束的年度．每季度最后一月的第一个日历日 |
| BQS-JAN 、 BQS-FES … | BusinessQuarterBegin | 对于以指定月份结束的年度，每季度最后一月的第一个工作日 |
| A-JAN 、A-FEB … | YearEnd | 每年指定月份（ JAN 、 FEB 、 MAR , APR 、 MAY 、 JUN 、 JUL 、 AUG 、 SEP 、 OCT 、 NOV 、 DEC）的最后一个日历日 |
| BA-JAN、 BA-FEB… | BussinessYearEnd | 每年指定月份的最后一个工作日 |
| AS-JAN 、AS-FEB… | YearBegin | 每年指定月份的第一个日历日 |
| BAS-JAN 、BAS-FEB… | BusinessYearBegin | 每年指定月份的第一个工作日 |
WOM日期
WOM（Week Of Month）是一种非常实用的频率类，它以WOM开头。它使你能获 得诸如“每月第3个星期五”之类的日期：
In [113]: rng = pd.date_range('2012-01-01', '2012-09-01', freq='WOM-3FRI')
In [114]: rng
Out[114]: DatetimeIndex(['2012-01-20', '2012-02-17', '2012-03-16', '2012-04-20',
'2012-05-18', '2012-06-15', '2012-07-20', '2012-08-17'],
dtype='datetime64[ns]', freq='WOM-3FRI')
美国的股票期权交易人会意识到这些日子就是标准的月度到期日。
移动（超前和滞后）数据
移动（shifting）指的是沿着时间轴将数据前移或后移。Series和DataFrame都有一 个shift方法用于执行单纯的前移或后移操作，保持索引不变：
In [116]: ts = pd.Series(np.random.randn(4),index=pd.date_range('1/1/2000',
periods=4 , freq='M'))
In [117]: ts
Out[117]: 2000-01-31 -0.869639
2000-02-29 0.431646
2000-03-31 -0.255513
2000-04-30 -0.218929
Freq: M, dtype: float64
In [118]: ts.shift(2)
Out[118]: 2000-01-31 NaN
2000-02-29 NaN
2000-03-31 -0.869639
2000-04-30 0.431646
Freq: M, dtype: float64In [119]: ts.shift(-2)
Out[119]: 2000-01-31 -0.255513
2000-02-29 -0.218929
2000-03-31 NaN
2000-04-30 NaN
Freq: M, dtype: float64
当我们这样进行移动时，就会在时间序列的前面或后面产生缺失数据。 shift通常用于计算一个时间序列或多个时间序列（如DataFrame的列）中的百分比 变化。可
以这样表达：
In [120]: ts / ts.shift(1) - 1
Out[120]: 2000-01-31 NaN
2000-02-29 -1.496351
2000-03-31 -1.591952
2000-04-30 -0.143179
Freq: M, dtype: float64
由于单纯的移位操作不会修改索引，所以部分数据会被丢弃。因此，如果频率已 知，则可以将其传给shift以便实现对时间戳进行位移而不是对数据进行简单位移：
In [121]: ts.shift(2, freq='M')# 加的是日期
Out[121]: 2000-03-31 -0.869639
2000-04-30 0.431646
2000-05-31 -0.255513
2000-06-30 -0.218929
Freq: M, dtype: float64
这里还可以使用其他频率，于是你就能非常灵活地对数据进行超前和滞后处理了：
In[123]: ts
Out[123]: 2000-01-31 -0.869639
2000-02-29 0.431646
2000-03-31 -0.255513
2000-04-30 -0.218929
Freq: M, dtype: float64
In [124]: ts.shift(3, freq='D') # 加的是日期
Out[124]: 2000-02-03 -0.869639
2000-03-03 0.431646
2000-04-03 -0.255513
2000-05-03 -0.218929
dtype: float64
In [125]: ts.shift(1, freq='90T')
Out[125]: 2000-01-31 01:30:00 -0.869639
2000-02-29 01:30:00 0.431646
2000-03-31 01:30:00 -0.255513
2000-04-30 01:30:00 -0.218929
Freq: M, dtype: float64
通过偏移量对日期进行位移
pandas的日期偏移量还可以用在datetime或Timestamp对象上：
In [126]: from pandas.tseries.offsets import Day, MonthEnd
now = datetime(2011, 11, 17)
now + 3 * Day()
Out[126]: Timestamp('2011-11-20 00:00:00')
如果加的是锚点偏移量（比如MonthEnd），第一次增量会将原日期向前滚动到符 合频率规则的下一个日期：
In [127]: now + MonthEnd()
Out[127]: Timestamp('2011-11-30 00:00:00')
In [128]: now + MonthEnd(2)
Out[128]: Timestamp('2011-12-31 00:00:00')
通过锚点偏移量的rollforward和rollback方法，可明确地将日期向前或向后“滚动”：
In [129]: offset = MonthEnd()
In [130]: offset
Out[130]:
In [134]: now
Out[134]: datetime.datetime(2011, 11, 17, 0, 0)
In [131]: offset.rollforward(now)
Out[131]: Timestamp('2011-11-30 00:00:00')
In [132]: offset.rollback(now)
Out[132]: Timestamp('2011-10-31 00:00:00')
日期偏移量还有一个巧妙的用法，即结合groupby使用这两个“滚动”方法：
In [136]: ts = pd.Series(np.random.randn(20),index=pd.date_range('1/15/2000',
periods=20, freq='4d'))
In [140]: ts
Out[140]: 2000-01-15 1.554447
2000-01-19 2.399580
2000-01-23 -0.762667
2000-01-27 0.112696
2000-01-31 1.114518
2000-02-04 0.923506
2000-02-08 -0.185199
2000-02-12 1.016654
2000-02-16 -0.333582
2000-02-20 1.022324
2000-02-24 0.113901
2000-02-28 -0.066764
2000-03-03 1.725752
2000-03-07 -0.673308
2000-03-11 -1.429432
2000-03-15 1.805766
2000-03-19 -0.366428
2000-03-23 -0.048395
2000-03-27 -0.149863
2000-03-31 0.819384
Freq: 4D, dtype: float64
In [139]: ts.groupby(offset.rollforward).mean()
Out[139]: 2000-01-31 0.883715
2000-02-29 0.355834
2000-03-31 0.210435
dtype: float64
当然，更简单、更快速地实现该功能的办法是使用resample：
In [141]: ts.resample('M').mean()
Out[141]: 2000-01-31 0.883715
2000-02-29 0.355834
2000-03-31 0.210435
Freq: M, dtype: float64
时区处理
时间序列处理工作中最让人不爽的就是对时区的处理。许多人都选择以协调世界时 （UTC，它是格林尼治标准时间（Greenwich Mean Time）的接替者，目前已经
是 国际标准了）来处理时间序列。时区是以UTC偏移量的形式表示的。例如，夏令时 期间，纽约比UTC慢4小时，而在全年其他时间则比UTC慢5小时。
在Python中，时区信息来自第三方库pytz，它使Python可以使用Olson数据库（汇 编了世界时区信息）。这对历史数据非常重要，这是因为由于各地政府的各种突发
奇想，夏令时转变日期（甚至UTC偏移量）已经发生过多次改变了。就拿美国来 说，DST转变时间自1900年以来就改变过多次！
有关pytz库的更多信息，请查阅其文档。就本书而言，由于pandas包装了pytz的功 能，因此你可以不用记忆其API，只要记得时区的名称即可。时区名可以在shell中
看到，也可以通过文档查看：
In [142]: import pytz
In [143]: pytz.common_timezones[-5:]
Out[143]: ['US/Eastern', 'US/Hawaii', 'US/Mountain', 'US/Pacific', 'UTC']
要从pytz中获取时区对象，使用pytz.timezone即可：In [144]: tz = pytz.timezone(‘America/New_York’)
In [145]: tz
Out[145]:
pandas中的方法既可以接受时区名也可以接受这些对象。
时区本地化和转换
默认情况下，pandas中的时间序列是单纯（naive）的时区。看看下面这个时间序列：
In [146]: rng = pd.date_range('3/9/2012 9:30', periods=6, freq=' D')
In [147]: rng
Out[147]: DatetimeIndex(['2012-03-09 09:30:00', '2012-03-10 09:30:00',
'2012-03-11 09:30:00', '2012-03-12 09:30:00',
'2012-03-13 09:30:00', '2012-03-14 09:30:00'],
dtype='datetime64[ns]', freq='D')
In [150]: ts = pd.Series(np.random.randn(len(rng)), index=rng)
In [151]: ts
Out[151]: 2012-03-09 09:30:00 -0.499277
2012-03-10 09:30:00 -0.761171
2012-03-11 09:30:00 -0.035294
2012-03-12 09:30:00 1.063507
2012-03-13 09:30:00 -1.207527
2012-03-14 09:30:00 0.897861
Freq: D, dtype: float64
其索引的tz字段为None：
In [152]: print(ts.index.tz)
None
可以用时区集生成日期范围：
In [153]: pd.date_range('3/9/2012 9:30', periods=10, freq='D', tz='UTC')
Out[153]: DatetimeIndex(['2012-03-09 09:30:00+00:00', '2012-03-10 09:30:00+00:00',
'2012-03-11 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
'2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00',
'2012-03-15 09:30:00+00:00', '2012-03-16 09:30:00+00:00',
'2012-03-17 09:30:00+00:00', '2012-03-18 09:30:00+00:00'],
dtype='datetime64[ns, UTC]', freq='D')
从单纯到本地化的转换是通过tz_localize方法处理的：
In [154]: ts
Out[154]: 2012-03-09 09:30:00 -0.499277
2012-03-10 09:30:00 -0.761171
2012-03-11 09:30:00 -0.035294
2012-03-12 09:30:00 1.063507
2012-03-13 09:30:00 -1.207527
2012-03-14 09:30:00 0.897861
Freq: D, dtype: float64
In [155]: ts_utc = ts.tz_localize('UTC')
In [156]: ts_utc
Out[156]: 2012-03-09 09:30:00+00:00 -0.499277
2012-03-10 09:30:00+00:00 -0.761171
2012-03-11 09:30:00+00:00 -0.035294
2012-03-12 09:30:00+00:00 1.063507
2012-03-13 09:30:00+00:00 -1.207527
2012-03-14 09:30:00+00:00 0.897861
Freq: D, dtype: float64
In [157]: ts_utc.index
Out[157]: DatetimeIndex(['2012-03-09 09:30:00+00:00', '2012-03-10 09:30:00+00:00',
'2012-03-11 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
'2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00'],
dtype='datetime64[ns, UTC]', freq='D')
In [158]: ts_utc.tz_convert('America/New_York')
Out[158]: 2012-03-09 04:30:00-05:00 -0.499277
2012-03-10 04:30:00-05:00 -0.761171
2012-03-11 05:30:00-04:00 -0.035294
2012-03-12 05:30:00-04:00 1.063507
2012-03-13 05:30:00-04:00 -1.207527
2012-03-14 05:30:00-04:00 0.897861
Freq: D, dtype: float64
对于上面这种时间序列（它跨越了美国东部时区的夏令时转变期），我们可以将其 本地化到EST，然后转换为UTC或柏林时间：
In [160]: ts_eastern = ts.tz_localize('America/New_York')
ts_eastern.tz_convert('UTC')
Out[160]: 2012-03-09 14:30:00+00:00 -0.499277
2012-03-10 14:30:00+00:00 -0.761171
2012-03-11 13:30:00+00:00 -0.035294
2012-03-12 13:30:00+00:00 1.063507
2012-03-13 13:30:00+00:00 -1.207527
2012-03-14 13:30:00+00:00 0.897861
Freq: D, dtype: float64
In [161]: ts_eastern.tz_convert('Europe/Berlin')
Out[161]: 2012-03-09 15:30:00+01:00 -0.499277
2012-03-10 15:30:00+01:00 -0.761171
2012-03-11 14:30:00+01:00 -0.035294
2012-03-12 14:30:00+01:00 1.063507
2012-03-13 14:30:00+01:00 -1.207527
2012-03-14 14:30:00+01:00 0.897861
Freq: D, dtype: float64
tz_localize和tz_convert也是DatetimeIndex的实例方法：
In [162]: ts.index.tz_localize('Asia/Shanghai')
Out[162]: DatetimeIndex(['2012-03-09 09:30:00+08:00', '2012-03-10 09:30:00+08:00',
'2012-03-11 09:30:00+08:00', '2012-03-12 09:30:00+08:00',
'2012-03-13 09:30:00+08:00', '2012-03-14 09:30:00+08:00'],
dtype='datetime64[ns, Asia/Shanghai]', freq='D')
注意：对单纯时间戳的本地化操作还会检查夏令时转变期附近容易混淆或不存在的时间。~
操作时区意识型Timestamp对象
跟时间序列和日期范围差不多，独立的Timestamp对象也能被从单纯型（naive）本 地化为时区意识型（time zone-aware），并从一个时区转换到另一个时区：
In [163]: stamp = pd.Timestamp('2011-03-12 04:00')
In [164]: stamp
Out[164]: Timestamp('2011-03-12 04:00:00')
In [165]: stamp_utc = stamp.tz_localize('utc')
In [166]: stamp_utc
Out[166]: Timestamp('2011-03-12 04:00:00+0000', tz='UTC')
In [167]: stamp_utc.tz_convert('America/New_York')
Out[167]: Timestamp('2011-03-11 23:00:00-0500', tz='America/New_York')
在创建Timestamp时，还可以传入一个时区信息：
n [169]: stamp_moscow = pd.Timestamp('2011-03-12 04:00', tz='Europe/Moscow')
In [170]: stamp_moscow
Out[170]: Timestamp('2011-03-12 04:00:00+0300', tz='Europe/Moscow')
时区意识型Timestamp对象在内部保存了一个UTC时间戳值（自UNIX纪元（1970 年1月1日）算起的纳秒数）。这个UTC值在时区转换过程中是不会发生变化的：
In [171]: stamp_utc.value
Out[171]: 1299902400000000000
In [172]: stamp_utc.tz_convert('America/New_York').value
Out[172]: 1299902400000000000
当使用pandas的DateOffset对象执行时间算术运算时，运算过程会自动关注是否存 在夏令时转变期。这里，我们创建了在DST转变之前的时间戳。首先，来看夏令
时 转变前的30分钟：
In [174]: from pandas.tseries.offsets import Hour
stamp = pd.Timestamp('2012-03-12 01:30', tz='US/Eastern')
In [175]: stamp
Out[175]: Timestamp('2012-03-12 01:30:00-0400', tz='US/Eastern')
In [176]: stamp + Hour()
Out[176]: Timestamp('2012-03-12 02:30:00-0400', tz='US/Eastern')
然后，夏令时转变前90分钟：
In [178]: stamp = pd.Timestamp('2012-11-04 00:30', tz='US/Eastern')
In [179]: stamp
Out[179]: Timestamp('2012-11-04 00:30:00-0400', tz='US/Eastern')
In [180]: stamp + 2 * Hour()
Out[180]: Timestamp('2012-11-04 01:30:00-0500', tz='US/Eastern')
不同时区之间的运算
如果两个时间序列的时区不同，在将它们合并到一起时，最终结果就会是UTC。由 于时间戳其实是以UTC存储的，所以这是一个很简单的运算，并不需要发生任何
转 换：
In [181]: rng = pd.date_range('3/7/2012 9:30', periods=10, freq= 'B')
In [182]: ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
Out[182]: 2012-03-07 09:30:00 -0.348491
2012-03-08 09:30:00 0.708435
2012-03-09 09:30:00 -1.502973
2012-03-12 09:30:00 1.307406
2012-03-13 09:30:00 -1.430020
2012-03-14 09:30:00 1.920142
2012-03-15 09:30:00 0.543014
2012-03-16 09:30:00 1.769601
2012-03-19 09:30:00 0.807448
2012-03-20 09:30:00 -1.491706
Freq: B, dtype: float64
In [183]: ts1 = ts[:7].tz_localize('Europe/London')
In [184]: ts1
Out[184]: 2012-03-07 09:30:00+00:00 -0.348491
2012-03-08 09:30:00+00:00 0.708435
2012-03-09 09:30:00+00:00 -1.502973
2012-03-12 09:30:00+00:00 1.307406
2012-03-13 09:30:00+00:00 -1.430020
2012-03-14 09:30:00+00:00 1.920142
2012-03-15 09:30:00+00:00 0.543014
Freq: B, dtype: float64
In [185]: ts2 = ts1[2:].tz_convert('Europe/Moscow')In [186]: ts2
Out[186]: 2012-03-09 13:30:00+04:00 -1.502973
2012-03-12 13:30:00+04:00 1.307406
2012-03-13 13:30:00+04:00 -1.430020
2012-03-14 13:30:00+04:00 1.920142
2012-03-15 13:30:00+04:00 0.543014
Freq: B, dtype: float64
In [187]: result = ts1 + ts2
In [188]: result
Out[188]: 2012-03-07 09:30:00+00:00 NaN
2012-03-08 09:30:00+00:00 NaN
2012-03-09 09:30:00+00:00 -3.005945
2012-03-12 09:30:00+00:00 2.614812
2012-03-13 09:30:00+00:00 -2.860040
2012-03-14 09:30:00+00:00 3.840284
2012-03-15 09:30:00+00:00 1.086028
Freq: B, dtype: float64
In [189]: result.index
Out[189]: DatetimeIndex(['2012-03-07 09:30:00+00:00', '2012-03-08 09:30:00+00:00',
'2012-03-09 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
'2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00',
'2012-03-15 09:30:00+00:00'],
dtype='datetime64[ns, UTC]', freq='B')
本文内容参考自《Python for Data Analysis》