第11章 时间序列
时间序列(time series)数据是一种重要的结构化数据形式,应用于多个领域,包括金融学、经济学、生态学、神经科学、物理学等。在多个时间点观察或测量到的任何事物都可以形成一段时间序列。很多时间序列是固定频率的,也就是说,数据点是根据某种规律定期出现的(比如每15秒、每5分钟、每月出现一次)。时间序列也可以是不定期的,没有固定的时间单位或单位之间的偏移量。时间序列数据的意义取决于具体的应用场景,主要有以下几种:
  • 时间戳(timestamp),特定的时刻。
  • 固定时期(period),如2007年1月或2010年全年。
  • 时间间隔(interval),由起始和结束时间戳表示。时期(period)可以被看做间隔(interval)的特例。
  • 实验或过程时间,每个时间点都是相对于特定起始时间的一个度量。例如,从放入烤箱时起,每秒钟饼干的直径。
本章主要讲解前3种时间序列。许多技术都可用于处理实验型时间序列,其索引可能是一个整数或浮点数(表示从实验开始算起已经过去的时间)。最简单也最常见的时间序列都是用时间戳进行索引的。
提示:pandas也支持基于timedeltas的指数,它可以有效代表实验或经过的时间。这本书不涉及timedelta指数,但你可以学习pandas的文档(http://pandas.pydata.org/)。
pandas提供了许多内置的时间序列处理工具和数据算法。因此,你可以高效处理非常大的时间序列,轻松地进行切片/切块、聚合、对定期/不定期的时间序列进行重采样等。有些工具特别适合金融和经济应用,你当然也可以用它们来分析服务器日志数据。

11.1 日期和时间数据类型及工具

Python标准库包含用于日期(date)和时间(time)数据的数据类型,而且还有日历方面的功能。我们主要会用到datetime、time以及calendar模块。datetime.datetime(也可以简写为datetime)是用得最多的数据类型:
1
In [10]: from datetime import datetime
2
3
In [11]: now = datetime.now()
4
5
In [12]: now
6
Out[12]: datetime.datetime(2017, 9, 25, 14, 5, 52, 72973)
7
8
In [13]: now.year, now.month, now.day
9
Out[13]: (2017, 9, 25)
Copied!
datetime以毫秒形式存储日期和时间。timedelta表示两个datetime对象之间的时间差:
1
In [14]: delta = datetime(2011, 1, 7) - datetime(2008, 6, 24, 8, 15)
2
3
In [15]: delta
4
Out[15]: datetime.timedelta(926, 56700)
5
6
In [16]: delta.days
7
Out[16]: 926
8
9
In [17]: delta.seconds
10
Out[17]: 56700
Copied!
可以给datetime对象加上(或减去)一个或多个timedelta,这样会产生一个新对象:
1
In [18]: from datetime import timedelta
2
3
In [19]: start = datetime(2011, 1, 7)
4
5
In [20]: start + timedelta(12)
6
Out[20]: datetime.datetime(2011, 1, 19, 0, 0)
7
8
In [21]: start - 2 * timedelta(12)
9
Out[21]: datetime.datetime(2010, 12, 14, 0, 0)
Copied!
datetime模块中的数据类型参见表10-1。虽然本章主要讲的是pandas数据类型和高级时间序列处理,但你肯定会在Python的其他地方遇到有关datetime的数据类型。
表11-1 datetime模块中的数据类型
Could not load image
tzinfo 存储时区信息的基本类型

字符串和datetime的相互转换

利用str或strftime方法(传入一个格式化字符串),datetime对象和pandas的Timestamp对象(稍后就会介绍)可以被格式化为字符串:
1
In [22]: stamp = datetime(2011, 1, 3)
2
3
In [23]: str(stamp)
4
Out[23]: '2011-01-03 00:00:00'
5
6
In [24]: stamp.strftime('%Y-%m-%d')
7
Out[24]: '2011-01-03'
Copied!
表11-2列出了全部的格式化编码。
表11-2 datetime格式定义(兼容ISO C89)
Could not load image
Could not load image
datetime.strptime可以用这些格式化编码将字符串转换为日期:
1
In [25]: value = '2011-01-03'
2
3
In [26]: datetime.strptime(value, '%Y-%m-%d')
4
Out[26]: datetime.datetime(2011, 1, 3, 0, 0)
5
6
In [27]: datestrs = ['7/6/2011', '8/6/2011']
7
8
In [28]: [datetime.strptime(x, '%m/%d/%Y') for x in datestrs]
9
Out[28]:
10
[datetime.datetime(2011, 7, 6, 0, 0),
11
datetime.datetime(2011, 8, 6, 0, 0)]
Copied!
datetime.strptime是通过已知格式进行日期解析的最佳方式。但是每次都要编写格式定义是很麻烦的事情,尤其是对于一些常见的日期格式。这种情况下,你可以用dateutil这个第三方包中的parser.parse方法(pandas中已经自动安装好了):
1
In [29]: from dateutil.parser import parse
2
3
In [30]: parse('2011-01-03')
4
Out[30]: datetime.datetime(2011, 1, 3, 0, 0)
Copied!
dateutil可以解析几乎所有人类能够理解的日期表示形式:
1
In [31]: parse('Jan 31, 1997 10:45 PM')
2
Out[31]: datetime.datetime(1997, 1, 31, 22, 45)
Copied!
在国际通用的格式中,日出现在月的前面很普遍,传入dayfirst=True即可解决这个问题:
1
In [32]: parse('6/12/2011', dayfirst=True)
2
Out[32]: datetime.datetime(2011, 12, 6, 0, 0)
Copied!
pandas通常是用于处理成组日期的,不管这些日期是DataFrame的轴索引还是列。to_datetime方法可以解析多种不同的日期表示形式。对标准日期格式(如ISO8601)的解析非常快:
1
In [33]: datestrs = ['2011-07-06 12:00:00', '2011-08-06 00:00:00']
2
3
In [34]: pd.to_datetime(datestrs)
4
Out[34]: DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00'], dtype='dat
5
etime64[ns]', freq=None)
Copied!
它还可以处理缺失值(None、空字符串等):
1
In [35]: idx = pd.to_datetime(datestrs + [None])
2
3
In [36]: idx
4
Out[36]: DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00', 'NaT'], dty
5
pe='datetime64[ns]', freq=None)
6
7
In [37]: idx[2]
8
Out[37]: NaT
9
10
In [38]: pd.isnull(idx)
11
Out[38]: array([False, False, True], dtype=bool)
Copied!
NaT(Not a Time)是pandas中时间戳数据的null值。
注意:dateutil.parser是一个实用但不完美的工具。比如说,它会把一些原本不是日期的字符串认作是日期(比如"42"会被解析为2042年的今天)。
datetime对象还有一些特定于当前环境(位于不同国家或使用不同语言的系统)的格式化选项。例如,德语或法语系统所用的月份简写就与英语系统所用的不同。表11-3进行了总结。
表11-3 特定于当前环境的日期格式
Could not load image

11.2 时间序列基础

pandas最基本的时间序列类型就是以时间戳(通常以Python字符串或datatime对象表示)为索引的Series:
1
In [39]: from datetime import datetime
2
3
In [40]: dates = [datetime(2011, 1, 2), datetime(2011, 1, 5),
4
....: datetime(2011, 1, 7), datetime(2011, 1, 8),
5
....: datetime(2011, 1, 10), datetime(2011, 1, 12)]
6
7
In [41]: ts = pd.Series(np.random.randn(6), index=dates)
8
9
In [42]: ts
10
Out[42]:
11
2011-01-02 -0.204708
12
2011-01-05 0.478943
13
2011-01-07 -0.519439
14
2011-01-08 -0.555730
15
2011-01-10 1.965781
16
2011-01-12 1.393406
17
dtype: float64
Copied!
这些datetime对象实际上是被放在一个DatetimeIndex中的:
1
In [43]: ts.index
2
Out[43]:
3
DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07', '2011-01-08',
4
'2011-01-10', '2011-01-12'],
5
dtype='datetime64[ns]', freq=None)
Copied!
跟其他Series一样,不同索引的时间序列之间的算术运算会自动按日期对齐:
1
In [44]: ts + ts[::2]
2
Out[44]:
3
2011-01-02 -0.409415
4
2011-01-05 NaN
5
2011-01-07 -1.038877
6
2011-01-08 NaN
7
2011-01-10 3.931561
8
2011-01-12 NaN
9
dtype: float64
Copied!
ts[::2] 是每隔两个取一个。
pandas用NumPy的datetime64数据类型以纳秒形式存储时间戳:
1
In [45]: ts.index.dtype
2
Out[45]: dtype('<M8[ns]')
Copied!
DatetimeIndex中的各个标量值是pandas的Timestamp对象:
1
In [46]: stamp = ts.index[0]
2
3
In [47]: stamp
4
Out[47]: Timestamp('2011-01-02 00:00:00')
Copied!
只要有需要,TimeStamp可以随时自动转换为datetime对象。此外,它还可以存储频率信息(如果有的话),且知道如何执行时区转换以及其他操作。稍后将对此进行详细讲解。

索引、选取、子集构造

当你根据标签索引选取数据时,时间序列和其它的pandas.Series很像:
1
In [48]: stamp = ts.index[2]
2
3
In [49]: ts[stamp]
4
Out[49]: -0.51943871505673811
Copied!
还有一种更为方便的用法:传入一个可以被解释为日期的字符串:
1
In [50]: ts['1/10/2011']
2
Out[50]: 1.9657805725027142
3
4
In [51]: ts['20110110']
5
Out[51]: 1.9657805725027142
Copied!
对于较长的时间序列,只需传入“年”或“年月”即可轻松选取数据的切片:
1
In [52]: longer_ts = pd.Series(np.random.randn(1000),
2
....: index=pd.date_range('1/1/2000', periods=1000))
3
4
In [53]: longer_ts
5
Out[53]:
6
2000-01-01 0.092908
7
2000-01-02 0.281746
8
2000-01-03 0.769023
9
2000-01-04 1.246435
10
2000-01-05 1.007189
11
2000-01-06 -1.296221
12
2000-01-07 0.274992
13
2000-01-08 0.228913
14
2000-01-09 1.352917
15
2000-01-10 0.886429
16
...
17
2002-09-17 -0.139298
18
2002-09-18 -1.159926
19
2002-09-19 0.618965
20
2002-09-20 1.373890
21
2002-09-21 -0.983505
22
2002-09-22 0.930944
23
2002-09-23 -0.811676
24
2002-09-24 -1.830156
25
2002-09-25 -0.138730
26
2002-09-26 0.334088
27
Freq: D, Length: 1000, dtype: float64
28
29
In [54]: longer_ts['2001']
30
Out[54]:
31
2001-01-01 1.599534
32
2001-01-02 0.474071
33
2001-01-03 0.151326
34
2001-01-04 -0.542173
35
2001-01-05 -0.475496
36
2001-01-06 0.106403
37
2001-01-07 -1.308228
38
2001-01-08 2.173185
39
2001-01-09 0.564561
40
2001-01-10 -0.190481
41
...
42
2001-12-22 0.000369
43
2001-12-23 0.900885
44
2001-12-24 -0.454869
45
2001-12-25 -0.864547
46
2001-12-26 1.129120
47
2001-12-27 0.057874
48
2001-12-28 -0.433739
49
2001-12-29 0.092698
50
2001-12-30 -1.397820
51
2001-12-31 1.457823
52
Freq: D, Length: 365, dtype: float64
Copied!
这里,字符串“2001”被解释成年,并根据它选取时间区间。指定月也同样奏效:
1
In [55]: longer_ts['2001-05']
2
Out[55]:
3
2001-05-01 -0.622547
4
2001-05-02 0.936289
5
2001-05-03 0.750018
6
2001-05-04 -0.056715
7
2001-05-05 2.300675
8
2001-05-06 0.569497
9
2001-05-07 1.489410
10
2001-05-08 1.264250
11
2001-05-09 -0.761837
12
2001-05-10 -0.331617
13
...
14
2001-05-22 0.503699
15
2001-05-23 -1.387874
16
2001-05-24 0.204851
17
2001-05-25 0.603705
18
2001-05-26 0.545680
19
2001-05-27 0.235477
20
2001-05-28 0.111835
21
2001-05-29 -1.251504
22
2001-05-30 -2.949343
23
2001-05-31 0.634634
24
Freq: D, Length: 31, dtype: float64
Copied!
datetime对象也可以进行切片:
1
In [56]: ts[datetime(2011, 1, 7):]
2
Out[56]:
3
2011-01-07 -0.519439
4
2011-01-08 -0.555730
5
2011-01-10 1.965781
6
2011-01-12 1.393406
7
dtype: float64
Copied!
由于大部分时间序列数据都是按照时间先后排序的,因此你也可以用不存在于该时间序列中的时间戳对其进行切片(即范围查询):
1
In [57]: ts
2
Out[57]:
3
2011-01-02 -0.204708
4
2011-01-05 0.478943
5
2011-01-07 -0.519439
6
2011-01-08 -0.555730
7
2011-01-10 1.965781
8
2011-01-12 1.393406
9
dtype: float64
10
11
In [58]: ts['1/6/2011':'1/11/2011']
12
Out[58]:
13
2011-01-07 -0.519439
14
2011-01-08 -0.555730
15
2011-01-10 1.965781
16
dtype: float64
Copied!
跟之前一样,你可以传入字符串日期、datetime或Timestamp。注意,这样切片所产生的是原时间序列的视图,跟NumPy数组的切片运算是一样的。
这意味着,没有数据被复制,对切片进行修改会反映到原始数据上。
此外,还有一个等价的实例方法也可以截取两个日期之间TimeSeries:
1
In [59]: ts.truncate(after='1/9/2011')
2
Out[59]:
3
2011-01-02 -0.204708
4
2011-01-05 0.478943
5
2011-01-07 -0.519439
6
2011-01-08 -0.555730
7
dtype: float64
Copied!
面这些操作对DataFrame也有效。例如,对DataFrame的行进行索引:
1
In [60]: dates = pd.date_range('1/1/2000', periods=100, freq='W-WED')
2
3
In [61]: long_df = pd.DataFrame(np.random.randn(100, 4),
4
....: index=dates,
5
....: columns=['Colorado', 'Texas',
6
....: 'New York', 'Ohio'])
7
8
In [62]: long_df.loc['5-2001']
9
Out[62]:
10
Colorado Texas New York Ohio
11
2001-05-02 -0.006045 0.490094 -0.277186 -0.707213
12
2001-05-09 -0.560107 2.735527 0.927335 1.513906
13
2001-05-16 0.538600 1.273768 0.667876 -0.969206
14
2001-05-23 1.676091 -0.817649 0.050188 1.951312
15
2001-05-30 3.260383 0.963301 1.201206 -1.852001
Copied!

带有重复索引的时间序列

在某些应用场景中,可能会存在多个观测数据落在同一个时间点上的情况。下面就是一个例子:
1
In [63]: dates = pd.DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000',
2
....: '1/2/2000', '1/3/2000'])
3
In [64]: dup_ts = pd.Series(np.arange(5), index=dates)
4
5
In [65]: dup_ts
6
Out[65]:
7
2000-01-01 0
8
2000-01-02 1
9
2000-01-02 2
10
2000-01-02 3
11
2000-01-03 4
12
dtype: int64
Copied!
通过检查索引的is_unique属性,我们就可以知道它是不是唯一的:
1
In [66]: dup_ts.index.is_unique
2
Out[66]: False
Copied!
对这个时间序列进行索引,要么产生标量值,要么产生切片,具体要看所选的时间点是否重复:
1
In [67]: dup_ts['1/3/2000'] # not duplicated
2
Out[67]: 4
3
4
In [68]: dup_ts['1/2/2000'] # duplicated
5
Out[68]:
6
2000-01-02 1
7
2000-01-02 2
8
2000-01-02 3
9
dtype: int64
Copied!
假设你想要对具有非唯一时间戳的数据进行聚合。一个办法是使用groupby,并传入level=0:
1
In [69]: grouped = dup_ts.groupby(level=0)
2
3
In [70]: grouped.mean()
4
Out[70]:
5
2000-01-01 0
6
2000-01-02 2
7
2000-01-03 4
8
dtype: int64
9
10
In [71]: grouped.count()
11
Out[71]:
12
2000-01-01 1
13
2000-01-02 3
14
2000-01-03 1
15
dtype: int64
Copied!

11.3 日期的范围、频率以及移动

pandas中的原生时间序列一般被认为是不规则的,也就是说,它们没有固定的频率。对于大部分应用程序而言,这是无所谓的。但是,它常常需要以某种相对固定的频率进行分析,比如每日、每月、每15分钟等(这样自然会在时间序列中引入缺失值)。幸运的是,pandas有一整套标准时间序列频率以及用于重采样、频率推断、生成固定频率日期范围的工具。例如,我们可以将之前那个时间序列转换为一个具有固定频率(每日)的时间序列,只需调用resample即可:
1
In [72]: ts
2
Out[72]:
3
2011-01-02 -0.204708
4
2011-01-05 0.478943
5
2011-01-07 -0.519439
6
2011-01-08 -0.555730
7
2011-01-10 1.965781
8
2011-01-12 1.393406
9
dtype: float64
10
11
In [73]: resampler = ts.resample('D')
Copied!
字符串“D”是每天的意思。
频率的转换(或重采样)是一个比较大的主题,稍后将专门用一节来进行讨论(11.6小节)。这里,我将告诉你如何使用基本的频率和它的倍数。

生成日期范围

虽然我之前用的时候没有明说,但你可能已经猜到pandas.date_range可用于根据指定的频率生成指定长度的DatetimeIndex:
1
In [74]: index = pd.date_range('2012-04-01', '2012-06-01')
2
3
In [75]: index
4
Out[75]:
5
DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
6
'2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
7
'2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
8
'2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
9
'2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20',
10
'2012-04-21', '2012-04-22', '2012-04-23', '2012-04-24',
11
'2012-04-25', '2012-04-26', '2012-04-27', '2012-04-28',
12
'2012-04-29', '2012-04-30', '2012-05-01', '2012-05-02',
13
'2012-05-03', '2012-05-04', '2012-05-05', '2012-05-06',
14
'2012-05-07', '2012-05-08', '2012-05-09', '2012-05-10',
15
'2012-05-11', '2012-05-12', '2012-05-13', '2012-05-14',
16
'2012-05-15', '2012-05-16', '2012-05-17', '2012-05-18',
17
'2012-05-19', '2012-05-20', '2012-05-21', '2012-05-22',
18
'2012-05-23', '2012-05-24', '2012-05-25', '2012-05-26',
19
'2012-05-27', '2012-05-28', '2012-05-29', '2012-05-30',
20
'2012-05-31', '2012-06-01'],
21
dtype='datetime64[ns]', freq='D')
Copied!
默认情况下,date_range会产生按天计算的时间点。如果只传入起始或结束日期,那就还得传入一个表示一段时间的数字:
1
In [76]: pd.date_range(start='2012-04-01', periods=20)
2
Out[76]:
3
DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
4
'2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
5
'2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
6
'2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
7
'2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20'],
8
dtype='datetime64[ns]', freq='D')
9
10
In [77]: pd.date_range(end='2012-06-01', periods=20)
11
Out[77]:
12
DatetimeIndex(['2012-05-13', '2012-05-14', '2012-05-15', '2012-05-16',
13
'2012-05-17', '2012-05-18', '2012-05-19', '2012-05-20',
14
'2012-05-21', '2012-05-22', '2012-05-23', '2012-05-24',
15
'2012-05-25', '2012-05-26', '2012-05-27','2012-05-28',
16
'2012-05-29', '2012-05-30', '2012-05-31', '2012-06-01'],
17
dtype='datetime64[ns]', freq='D')
Copied!
起始和结束日期定义了日期索引的严格边界。例如,如果你想要生成一个由每月最后一个工作日组成的日期索引,可以传入"BM"频率(表示business end of month,表11-4是频率列表),这样就只会包含时间间隔内(或刚好在边界上的)符合频率要求的日期:
1
In [78]: pd.date_range('2000-01-01', '2000-12-01', freq='BM')
2
Out[78]:
3
DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-28',
4
'2000-05-31', '2000-06-30', '2000-07-31', '2000-08-31',
5
'2000-09-29', '2000-10-31', '2000-11-30'],
6
dtype='datetime64[ns]', freq='BM')
Copied!
表11-4 基本的时间序列频率(不完整)
Could not load image
Could not load image
Could not load image
date_range默认会保留起始和结束时间戳的时间信息(如果有的话):
1
In [79]: pd.date_range('2012-05-02 12:56:31', periods=5)
2
Out[79]:
3
DatetimeIndex(['2012-05-02 12:56:31', '2012-05-03 12:56:31',
4
'2012-05-04 12:56:31', '2012-05-05 12:56:31',
5
'2012-05-06 12:56:31'],
6
dtype='datetime64[ns]', freq='D')
Copied!
有时,虽然起始和结束日期带有时间信息,但你希望产生一组被规范化(normalize)到午夜的时间戳。normalize选项即可实现该功能:
1
In [80]: pd.date_range('2012-05-02 12:56:31', periods=5, normalize=True)
2
Out[80]:
3
DatetimeIndex(['2012-05-02', '2012-05-03', '2012-05-04', '2012-05-05',
4
'2012-05-06'],
5
dtype='datetime64[ns]', freq='D')
Copied!

频率和日期偏移量

pandas中的频率是由一个基础频率(base frequency)和一个乘数组成的。基础频率通常以一个字符串别名表示,比如"M"表示每月,"H"表示每小时。对于每个基础频率,都有一个被称为日期偏移量(date offset)的对象与之对应。例如,按小时计算的频率可以用Hour类表示:
1
In [81]: from pandas.tseries.offsets import Hour, Minute
2
3
In [82]: hour = Hour()
4
5
In [83]: hour
6
Out[83]: <Hour>
Copied!
传入一个整数即可定义偏移量的倍数:
1
In [84]: four_hours = Hour(4)
2
3
In [85]: four_hours
4
Out[85]: <4 * Hours>
Copied!
一般来说,无需明确创建这样的对象,只需使用诸如"H"或"4H"这样的字符串别名即可。在基础频率前面放上一个整数即可创建倍数:
1
In [86]: pd.date_range('2000-01-01', '2000-01-03 23:59', freq='4h')
2
Out[86]:
3
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 04:00:00',
4
'2000-01-01 08:00:00', '2000-01-01 12:00:00',
5
'2000-01-01 16:00:00', '2000-01-01 20:00:00',
6
'2000-01-02 00:00:00', '2000-01-02 04:00:00',
7
'2000-01-02 08:00:00', '2000-01-02 12:00:00',
8
'2000-01-02 16:00:00', '2000-01-02 20:00:00',
9
'2000-01-03 00:00:00', '2000-01-03 04:00:00',
10
'2000-01-03 08:00:00', '2000-01-03 12:00:00',
11
'2000-01-03 16:00:00', '2000-01-03 20:00:00'],
12
dtype='datetime64[ns]', freq='4H')
Copied!
大部分偏移量对象都可通过加法进行连接:
1
In [87]: Hour(2) + Minute(30)
2
Out[87]: <150 * Minutes>
Copied!
同理,你也可以传入频率字符串(如"2h30min"),这种字符串可以被高效地解析为等效的表达式:
1
In [88]: pd.date_range('2000-01-01', periods=10, freq='1h30min')
2
Out[88]:
3
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 01:30:00',
4
'2000-01-01 03:00:00', '2000-01-01 04:30:00',
5
'2000-01-01 06:00:00', '2000-01-01 07:30:00',
6
'2000-01-01 09:00:00', '2000-01-01 10:30:00',
7
'2000-01-01 12:00:00', '2000-01-01 13:30:00'],
8
dtype='datetime64[ns]', freq='90T')
Copied!
有些频率所描述的时间点并不是均匀分隔的。例如,"M"(日历月末)和"BM"(每月最后一个工作日)就取决于每月的天数,对于后者,还要考虑月末是不是周末。由于没有更好的术语,我将这些称为锚点偏移量(anchored offset)。
表11-4列出了pandas中的频率代码和日期偏移量类。
笔记:用户可以根据实际需求自定义一些频率类以便提供pandas所没有的日期逻辑,但具体的细节超出了本书的范围。
表11-4 时间序列的基础频率
Could not load image
Could not load image
Could not load image

WOM日期

WOM(Week Of Month)是一种非常实用的频率类,它以WOM开头。它使你能获得诸如“每月第3个星期五”之类的日期:
1
In [89]: rng = pd.date_range('2012-01-01', '2012-09-01', freq='WOM-3FRI')
2
3
In [90]: list(rng)
4
Out[90]:
5
[Timestamp('2012-01-20 00:00:00', freq='WOM-3FRI'),
6
Timestamp('2012-02-17 00:00:00', freq='WOM-3FRI'),
7
Timestamp('2012-03-16 00:00:00', freq='WOM-3FRI'),
8
Timestamp('2012-04-20 00:00:00', freq='WOM-3FRI'),
9
Timestamp('2012-05-18 00:00:00', freq='WOM-3FRI'),
10
Timestamp('2012-06-15 00:00:00', freq='WOM-3FRI'),
11
Timestamp('2012-07-20 00:00:00', freq='WOM-3FRI'),
12
Timestamp('2012-08-17 00:00:00', freq='WOM-3FRI')]
Copied!

移动(超前和滞后)数据

移动(shifting)指的是沿着时间轴将数据前移或后移。Series和DataFrame都有一个shift方法用于执行单纯的前移或后移操作,保持索引不变:
1
In [91]: ts = pd.Series(np.random.randn(4),
2
....: index=pd.date_range('1/1/2000', periods=4, freq='M'))
3
4
In [92]: ts
5
Out[92]:
6
2000-01-31 -0.066748
7
2000-02-29 0.838639
8
2000-03-31 -0.117388
9
2000-04-30 -0.517795
10
Freq: M, dtype: float64
11
12
In [93]: ts.shift(2)
13
Out[93]:
14
2000-01-31 NaN
15
2000-02-29 NaN
16
2000-03-31 -0.066748
17
2000-04-30 0.838639
18
Freq: M, dtype: float64
19
20
In [94]: ts.shift(-2)
21
Out[94]:
22
2000-01-31 -0.117388
23
2000-02-29 -0.517795
24
2000-03-31 NaN
25
2000-04-30 NaN
26
Freq: M, dtype: float64
Copied!
当我们这样进行移动时,就会在时间序列的前面或后面产生缺失数据。
shift通常用于计算一个时间序列或多个时间序列(如DataFrame的列)中的百分比变化。可以这样表达:
1
ts / ts.shift(1) - 1
Copied!
由于单纯的移位操作不会修改索引,所以部分数据会被丢弃。因此,如果频率已知,则可以将其传给shift以便实现对时间戳进行位移而不是对数据进行简单位移:
1
In [95]: ts.shift(2, freq='M')
2
Out[95]:
3
2000-03-31 -0.066748
4
2000-04-30 0.838639
5
2000-05-31 -0.117388
6
2000-06-30 -0.517795
7
Freq: M, dtype: float64
Copied!
这里还可以使用其他频率,于是你就能非常灵活地对数据进行超前和滞后处理了:
1
In [96]: ts.shift(3, freq='D')
2
Out[96]:
3
2000-02-03 -0.066748
4
2000-03-03 0.838639
5
2000-04-03 -0.117388
6
2000-05-03 -0.517795
7
dtype: float64
8
9
In [97]: ts.shift(1, freq='90T')
10
Out[97]:
11
2000-01-31 01:30:00 -0.066748
12
2000-02-29 01:30:00 0.838639
13
2000-03-31 01:30:00 -0.117388
14
2000-04-30 01:30:00 -0.517795
15
Freq: M, dtype: float64
Copied!

通过偏移量对日期进行位移

pandas的日期偏移量还可以用在datetime或Timestamp对象上:
1
In [98]: from pandas.tseries.offsets import Day, MonthEnd
2
3
In [99]: now = datetime(2011, 11, 17)
4
5
In [100]: now + 3 * Day()
6
Out[100]: Timestamp('2011-11-20 00:00:00')
Copied!
如果加的是锚点偏移量(比如MonthEnd),第一次增量会将原日期向前滚动到符合频率规则的下一个日期:
1
In [101]: now + MonthEnd()
2
Out[101]: Timestamp('2011-11-30 00:00:00')
3
4
In [102]: now + MonthEnd(2)
5
Out[102]: Timestamp('2011-12-31 00:00:00')
Copied!
通过锚点偏移量的rollforward和rollback方法,可明确地将日期向前或向后“滚动”:
1
In [103]: offset = MonthEnd()
2
3
In [104]: offset.rollforward(now)
4
Out[104]: Timestamp('2011-11-30 00:00:00')
5
6
In [105]: offset.rollback(now)
7
Out[105]: Timestamp('2011-10-31 00:00:00')
Copied!
日期偏移量还有一个巧妙的用法,即结合groupby使用这两个“滚动”方法:
1
In [106]: ts = pd.Series(np.random.randn(20),
2
.....: index=pd.date_range('1/15/2000', periods=20, freq='4d'))
3
4
In [107]: ts
5
Out[107]:
6
2000-01-15 -0.116696
7
2000-01-19 2.389645
8
2000-01-23 -0.932454
9
2000-01-27 -0.229331
10
2000-01-31 -1.140330
11
2000-02-04 0.439920
12
2000-02-08 -0.823758
13
2000-02-12 -0.520930
14
2000-02-16 0.350282
15
2000-02-20 0.204395
16
2000-02-24 0.133445
17
2000-02-28 0.327905
18
2000-03-03 0.072153
19
2000-03-07 0.131678
20
2000-03-11 -1.297459
21
2000-03-15 0.997747
22
2000-03-19 0.870955
23
2000-03-23 -0.991253
24
2000-03-27 0.151699
25
2000-03-31 1.266151
26
Freq: 4D, dtype: float64
27
28
In [108]: ts.groupby(offset.rollforward).mean()
29
Out[108]:
30
2000-01-31 -0.005833
31
2000-02-29 0.015894
32
2000-03-31 0.150209
33
dtype: float64
Copied!
当然,更简单、更快速地实现该功能的办法是使用resample(11.6小节将对此进行详细介绍):
1
In [109]: ts.resample('M').mean()
2
Out[109]:
3
2000-01-31 -0.005833
4
2000-02-29 0.015894
5
2000-03-31 0.150209
6
Freq: M, dtype: float64
Copied!

11.4 时区处理

时间序列处理工作中最让人不爽的就是对时区的处理。许多人都选择以协调世界时(UTC,它是格林尼治标准时间(Greenwich Mean Time)的接替者,目前已经是国际标准了)来处理时间序列。时区是以UTC偏移量的形式表示的。例如,夏令时期间,纽约比UTC慢4小时,而在全年其他时间则比UTC慢5小时。
在Python中,时区信息来自第三方库pytz,它使Python可以使用Olson数据库(汇编了世界时区信息)。这对历史数据非常重要,这是因为由于各地政府的各种突发奇想,夏令时转变日期(甚至UTC偏移量)已经发生过多次改变了。就拿美国来说,DST转变时间自1900年以来就改变过多次!
有关pytz库的更多信息,请查阅其文档。就本书而言,由于pandas包装了pytz的功能,因此你可以不用记忆其API,只要记得时区的名称即可。时区名可以在shell中看到,也可以通过文档查看:
1
In [110]: import pytz
2
3
In [111]: pytz.common_timezones[-5:]
4
Out[111]: ['US/Eastern', 'US/Hawaii', 'US/Mountain', 'US/Pacific', 'UTC']
Copied!
要从pytz中获取时区对象,使用pytz.timezone即可:
1
In [112]: tz = pytz.timezone('America/New_York')
2
3
In [113]: tz
4
Out[113]: <DstTzInfo 'America/New_York' LMT-1 day, 19:04:00 STD>
Copied!
pandas中的方法既可以接受时区名也可以接受这些对象。

时区本地化和转换

默认情况下,pandas中的时间序列是单纯(naive)的时区。看看下面这个时间序列:
1
In [114]: rng = pd.date_range('3/9/2012 9:30', periods=6, freq='D')
2
3
In [115]: ts = pd.Series(np.random.randn(len(rng)), index=rng)
4
5
In [116]: ts
6
Out[116]:
7
2012-03-09 09:30:00 -0.202469
8
2012-03-10 09:30:00 0.050718
9
2012-03-11 09:30:00 0.639869
10
2012-03-12 09:30:00 0.597594
11
2012-03-13 09:30:00 -0.797246
12
2012-03-14 09:30:00 0.472879
13
Freq: D, dtype: float64
Copied!
其索引的tz字段为None:
1
In [117]: print(ts.index.tz)
2
None
Copied!
可以用时区集生成日期范围:
1
In [118]: pd.date_range('3/9/2012 9:30', periods=10, freq='D', tz='UTC')
2
Out[118]:
3
DatetimeIndex(['2012-03-09 09:30:00+00:00', '2012-03-10 09:30:00+00:00',
4
'2012-03-11 09:30:00+00:00', '2012-03-12 09:30:00+00:00',
5
'2012-03-13 09:30:00+00:00', '2012-03-14 09:30:00+00:00',
6
'2012-03-15 09:30:00+00:00', '2012-03-16 09:30:00+00:00',
7
'2012-03-17 09:30:00+00:00', '2012-03-18 09:30:00+00:00'],
8
dtype='datetime64[ns, UTC]', freq='D')
Copied!
从单纯到本地化的转换是通过tz_localize方法处理的:
1
In [119]: ts
2
Out[119]:
3
2012-03-09 09:30:00 -0.202469
4
2012-03-10 09:30:00 0.050718
5
2012-03-11 09:30:00 0.639869
6
2012-03-12 09:30:00 0.597594
7
2012-03-13 09:30:00 -0.797246
8
2012-03-14 09:30:00 0.472879
9
Freq: D, dtype: float64
10
11
In [120]: ts_utc = ts.tz_localize('UTC')
12
13
In [121]: ts_utc
14
Out[121]:
15
2012-03-09 09:30:00+00:00 -0.202469
16
2012-03-10 09:30:00+00:00 0.050718
17
2012-03-11 09:30:00+00:00 0.639869
18
2012-03-12 09:30:00+00:00 0.597594
19
2012-03-13 09:30:00+00:00 -0.797246
20
2012-03-14 09:30:00+00:00 0.472879
21
Freq: D, dtype: float64
22
23
In [122]: ts_utc.index
24
Out[122]:
25