"时间序列（time series）数据是一种重要的结构化数据形式，应用于多个领域，包括金融学、经济学、生态学、神经科学、物理学等。在多个时间点观察或测量到的任何事物都可以形成一段时间序列。很多时间序列是固定频率的，也就是说，数据点是根据某种 ...."

风吹来的沙

Rpa 2604 号会员
python基础 • 0 回帖 • 356 浏览 • 2021-11-18 13:42:55

pandas 时间序列

时间序列（time series）数据是一种重要的结构化数据形式，应用于多个领域，包括金融学、经济学、生态学、神经科学、物理学等。在多个时间点观察或测量到的任何事物都可以形成一段时间序列。很多时间序列是固定频率的，也就是说，数据点是根据某种规律定期出现的（比如每 15 秒、每 5 分钟、每月出现一次）。时间序列也可以是不定期的，没有固定的时间单位或单位之间的偏移量。时间序列数据的意义取决于具体的应用场景，主要有以下几种：

时间戳（timestamp），特定的时刻。
固定时期（period），如 2007 年 1 月或 2010 年全年。
时间间隔（interval），由起始和结束时间戳表示。时期（period）可以被看做间隔（interval）的特例。
实验或过程时间，每个时间点都是相对于特定起始时间的一个度量。例如，从放入烤箱时起，每秒钟饼干的直径。
本章主要讲解前 3 种时间序列。许多技术都可用于处理实验型时间序列，其索引可能是一个整数或浮点数（表示从实验开始算起已经过去的时间）。最简单也最常见的时间序列都是用时间戳进行索引的。

提示：pandas 也支持基于 timedeltas 的指数，它可以有效代表实验或经过的时间。这本书不涉及 timedelta 指数，但你可以学习 pandas 的文档（http://pandas.pydata.org/）。

pandas 提供了许多内置的时间序列处理工具和数据算法。因此，你可以高效处理非常大的时间序列，轻松地进行切片 / 切块、聚合、对定期 / 不定期的时间序列进行重采样等。有些工具特别适合金融和经济应用，你当然也可以用它们来分析服务器日志数据。
1

日期和时间数据类型及工具
Python 标准库包含用于日期（date）和时间（time）数据的数据类型，而且还有日历方面的功能。我们主要会用到 datetime、time 以及 calendar 模块。datetime.datetime（也可以简写为 datetime）是用得最多的数据类型：

import pandas as pd
from datetime import datetime
now = datetime.now()
now
datetime.datetime(2019, 3, 19, 22, 1, 56, 406804)
now.year, now.month, now.day
(2019, 3, 19)
datetime 以毫秒形式存储日期和时间。timedelta 表示两个 datetime 对象之间的时间差：

delta = datetime(2011, 1, 7) - datetime(2008, 6, 24, 8, 15)
delta
datetime.timedelta(926, 56700)
delta.days
926
delta.seconds
56700
可以给 datetime 对象加上（或减去）一个或多个 timedelta，这样会产生一个新对象：

from datetime import timedelta

start = datetime(2011, 1, 7)

start + timedelta(12)
datetime.datetime(2011, 1, 19, 0, 0)
start - 2 * timedelta(12)
datetime.datetime(2010, 12, 14, 0, 0)
datetime 模块中的数据类型参见表 11-1。虽然本章主要讲的是 pandas 数据类型和高级时间序列处理，但你肯定会在 Python 的其他地方遇到有关 datetime 的数据类型

类型说明
date 以公历形式存储日历日期（年，月，日）
time 将时间存储为时，分，秒，毫秒
datetime 存储日期和时间
timedelta 表示两个 datetime 值之间的差（日，秒，毫秒）
tzinfo 存储时区信息的基本类型
字符串和 datetime 的相互转换
利用 str 或 strftime 方法（传入一个格式化字符串），datetime 对象和 pandas 的 Timestamp 对象（稍后就会介绍）可以被格式化为字符串：

stamp = datetime(2011, 1, 3)

str(stamp)
‘2011-01-03 00:00:00’
stamp.strftime(‘%Y-%m-%d’)
‘2011-01-03’
表 11-2 列出了全部的格式化编码。

类型说明
%Y 4 位数的年
%y 2 位数的年
%m 2 位数的月 [01,12]
%d 2 位数的日 [01,31]
%H 时（24 小时制）[00, 23]
%I 时（12 小时制）[00, 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 时区偏移量，如果时区为 native，则返回空字符串
%F %Y-%m-%d 简写形式
%D %m/%d/%y 简写形式
datetime.strptime 可以用这些格式化编码将字符串转换为日期：

value = ‘2011-01-03’
datetime.strptime(value, ‘%Y-%m-%d’)
datetime.datetime(2011, 1, 3, 0, 0)
datestrs = [‘7/6/2011’, ‘8/6/2011’]

[datetime.strptime(x, ‘%m/%d/%Y’) for x in datestrs]
[datetime.datetime(2011, 7, 6, 0, 0), datetime.datetime(2011, 8, 6, 0, 0)]
datetime.strptime 是通过已知格式进行日期解析的最佳方式。但是每次都要编写格式定义是很麻烦的事情，尤其是对于一些常见的日期格式。这种情况下，你可以用 dateutil 这个第三方包中的 parser.parse 方法（pandas 中已经自动安装好了）：

from dateutil.parser import parse

parse(‘2011-01-03’)
datetime.datetime(2011, 1, 3, 0, 0)
dateutil 可以解析几乎所有人类能够理解的日期表示形式：

parse(‘Jan 31, 1997 10:45 PM’)
datetime.datetime(1997, 1, 31, 22, 45)
在国际通用的格式中，日出现在月的前面很普遍，传入 dayfirst=True 即可解决这个问题：

parse(‘6/12/2011’, dayfirst=True)
datetime.datetime(2011, 12, 6, 0, 0)
pandas 通常是用于处理成组日期的，不管这些日期是 DataFrame 的轴索引还是列。to_datetime 方法可以解析多种不同的日期表示形式。对标准日期格式（如 ISO8601）的解析非常快：

datestrs = [‘2011-07-06 12:00:00’, ‘2011-08-06 00:00:00’]

pd.to_datetime(datestrs)
DatetimeIndex([‘2011-07-06 12:00:00’, ‘2011-08-06 00:00:00’], dtype=‘datetime64[ns]’, freq=None)
它还可以处理缺失值（None、空字符串等）：

idx = pd.to_datetime(datestrs + [None])

idx
DatetimeIndex([‘2011-07-06 12:00:00’, ‘2011-08-06 00:00:00’, ‘NaT’], dtype=‘datetime64[ns]’, freq=None)
idx[2]
NaT
pd.isnull(idx)
array([False, False, True])
NaT（Not a Time）是 pandas 中时间戳数据的 null 值。

注意：dateutil.parser 是一个实用但不完美的工具。比如说，它会把一些原本不是日期的字符串认作是日期（比如 "42" 会被解析为 2042 年的今天）。

datetime 对象还有一些特定于当前环境（位于不同国家或使用不同语言的系统）的格式化选项。例如，德语或法语系统所用的月份简写就与英语系统所用的不同。表 11-3 进行了总结。

表 11-3 特定于当前环境的日期格式

类型说明
%a 星期几的简写
%A 星期几的全称
%b 月份的简写
%B 月份的全称
%c 完整的日期和时间，例如“Tue 01 May 2012 04:20:57 PM”
%p 不同环境中的 AM 或 PM
%x 适合于当前环境的日期格式，例如，在美国，“May 1, 2012”会产生“05/01/2012”
%X 适合于当前环境的时间格式，例如“04:24:12 PM”
时间序列基础
pandas 最基本的时间序列类型就是以时间戳（通常以 Python 字符串或 datatime 对象表示）为索引的 Series：

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)]

ts = pd.Series(np.random.randn(6), index=dates)
ts
2011-01-02 1.584305
2011-01-05 1.126032
2011-01-07 0.089850
2011-01-08 -0.435934
2011-01-10 0.007460
2011-01-12 -1.016462
dtype: float64
这些 datetime 对象实际上是被放在一个 DatetimeIndex 中的：

ts.index
DatetimeIndex([‘2011-01-02’, ‘2011-01-05’, ‘2011-01-07’, ‘2011-01-08’,
‘2011-01-10’, ‘2011-01-12’],
dtype=‘datetime64[ns]’, freq=None)
跟其他 Series 一样，不同索引的时间序列之间的算术运算会自动按日期对齐：

ts + ts[::2]
2011-01-02 3.168610
2011-01-05 NaN
2011-01-07 0.179701
2011-01-08 NaN
2011-01-10 0.014920
2011-01-12 NaN
dtype: float64
ts[::2] 是每隔两个取一个。

pandas 用 NumPy 的 datetime64 数据类型以纳秒形式存储时间戳

ts.index.dtype
dtype(‘<M8[ns]’)
DatetimeIndex 中的各个标量值是 pandas 的 Timestamp 对象：

stamp = ts.index[0]
stamp
Timestamp(‘2011-01-02 00:00:00’)
只要有需要，TimeStamp 可以随时自动转换为 datetime 对象。此外，它还可以存储频率信息（如果有的话），且知道如何执行时区转换以及其他操作。稍后将对此进行详细讲解。

索引、选取、子集构造
当你根据标签索引选取数据时，时间序列和其它的 pandas.Series 很像：

stamp = ts.index[2]
ts[stamp]
0.08985028255497494
还有一种更为方便的用法：传入一个可以被解释为日期的字符串：

ts[‘1/10/2011’]
0.0074598247835368815
ts[‘1/10/2011’]
0.0074598247835368815
对于较长的时间序列，只需传入“年”或“年月”即可轻松选取数据的切片：

longer_ts = pd.Series(np.random.randn(1000),
index=pd.date_range(‘1/1/2000’, periods=1000))

len(longer_ts)
1000
longer_ts.head()
2000-01-01 -0.069592
2000-01-02 -0.354321
2000-01-03 -0.044123
2000-01-04 -1.251155
2000-01-05 -0.149113
Freq: D, dtype: float64
longer_ts[‘2001’].tail()
2001-12-27 0.647617
2001-12-28 -1.062075
2001-12-29 -1.560355
2001-12-30 0.028578
2001-12-31 -0.564147
Freq: D, dtype: float64
这里，字符串“2001”被解释成年，并根据它选取时间区间。指定月也同样奏效：

longer_ts[‘2001-05’].head()
2001-05-01 1.007766
2001-05-02 -1.049496
2001-05-03 0.179904
2001-05-04 0.128080
2001-05-05 -0.428544
Freq: D, dtype: float64
datetime 对象也可以进行切片：

ts[datetime(2011, 1, 7):]
2011-01-07 0.089850
2011-01-08 -0.435934
2011-01-10 0.007460
2011-01-12 -1.016462
dtype: float64
由于大部分时间序列数据都是按照时间先后排序的，因此你也可以用不存在于该时间序列中的时间戳对其进行切片（即范围查询）：

ts
2011-01-02 1.584305
2011-01-05 1.126032
2011-01-07 0.089850
2011-01-08 -0.435934
2011-01-10 0.007460
2011-01-12 -1.016462
dtype: float64
ts[‘1/6/2011’:‘1/11/2011’]
2011-01-07 0.089850
2011-01-08 -0.435934
2011-01-10 0.007460
dtype: float64
跟之前一样，你可以传入字符串日期、datetime 或 Timestamp。注意，这样切片所产生的是原时间序列的视图，跟 NumPy 数组的切片运算是一样的。

这意味着，没有数据被复制，对切片进行修改会反映到原始数据上。

此外，还有一个等价的实例方法也可以截取两个日期之间 TimeSeries：

ts.truncate(after=‘1/9/2011’)
2011-01-02 1.584305
2011-01-05 1.126032
2011-01-07 0.089850
2011-01-08 -0.435934
dtype: float64
ts.truncate(before=‘1/5/2011’,after=‘1/9/2011’)
2011-01-05 1.126032
2011-01-07 0.089850
2011-01-08 -0.435934
dtype: float64
面这些操作对 DataFrame 也有效。例如，对 DataFrame 的行进行索引：

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’])

long_df.loc[‘5-2001’]

Colorado	Texas	New York	Ohio

2001-05-02 0.436372 -0.293713 0.010696 0.540794
2001-05-09 0.790312 -2.885652 -1.026365 -0.533633
2001-05-16 -0.545950 0.620089 -1.127443 2.079158
2001-05-23 -0.054685 0.697927 1.142663 0.176191
2001-05-30 -0.128105 1.702098 1.034434 0.963556
带有重复索引的时间序列
在某些应用场景中，可能会存在多个观测数据落在同一个时间点上的情况。下面就是一个例子：

dates = pd.DatetimeIndex([‘1/1/2000’, ‘1/2/2000’, ‘1/2/2000’,
‘1/2/2000’, ‘1/3/2000’])
dup_ts = pd.Series(np.arange(5), index=dates)
dup_ts

2000-01-01 0
2000-01-02 1
2000-01-02 2
2000-01-02 3
2000-01-03 4
dtype: int64
通过检查索引的 is_unique 属性，我们就可以知道它是不是唯一的：

dup_ts.index.is_unique
False
对这个时间序列进行索引，要么产生标量值，要么产生切片，具体要看所选的时间点是否重复：

dup_ts[‘1/3/2000’]
4
dup_ts[‘1/2/2000’] # duplicated
2000-01-02 1
2000-01-02 2
2000-01-02 3
dtype: int64
假设你想要对具有非唯一时间戳的数据进行聚合。一个办法是使用 groupby，并传入 level=0：

grouped = dup_ts.groupby(level=0)

grouped.mean()
2000-01-01 0
2000-01-02 2
2000-01-03 4
dtype: int64
grouped.count()
2000-01-01 1
2000-01-02 3
2000-01-03 1
dtype: int64
日期的范围、频率以及移动
pandas 中的原生时间序列一般被认为是不规则的，也就是说，它们没有固定的频率。对于大部分应用程序而言，这是无所谓的。但是，它常常需要以某种相对固定的频率进行分析，比如每日、每月、每 15 分钟等（这样自然会在时间序列中引入缺失值）。幸运的是，pandas 有一整套标准时间序列频率以及用于重采样、频率推断、生成固定频率日期范围的工具。例如，我们可以将之前那个时间序列转换为一个具有固定频率（每日）的时间序列，只需调用 resample 即可：

ts
2011-01-02 1.584305
2011-01-05 1.126032
2011-01-07 0.089850
2011-01-08 -0.435934
2011-01-10 0.007460
2011-01-12 -1.016462
dtype: float64
resampler = ts.resample(‘D’)
resampler
DatetimeIndexResampler [freq=, axis=0, closed=left, label=left, convention=start, base=0]
字符串“D”是每天的意思。

频率的转换（或重采样）是一个比较大的主题，稍后将专门用一节来进行讨论（11.6 小节）。这里，我将告诉你如何使用基本的频率和它的倍数。

生成日期范围
虽然我之前用的时候没有明说，但你可能已经猜到 pandas.date_range 可用于根据指定的频率生成指定长度的 DatetimeIndex：

index = pd.date_range(‘2012-04-01’, ‘2012-06-01’)
index
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 会产生按天计算的时间点。如果只传入起始或结束日期，那就还得传入一个表示一段时间的数字：

pd.date_range(start=‘2012-04-01’, periods=20)
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’)
pd.date_range(end=‘2012-06-01’, periods=20)
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，表 11-4 是频率列表），这样就只会包含时间间隔内（或刚好在边界上的）符合频率要求的日期

pd.date_range(‘2000-01-01’, ‘2000-12-01’, freq=‘BM’)
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’)
基本的时间序列频率（待补充）

别名偏移量类型说明
D Day 每日
B BusinessDay 每工作日
H Hour 每小时
T 或 min Minute 每分
S Second 每秒
L 或 ms Milli 每毫秒（即每千分之一秒）
U Micro 每微秒（即每百万分之一秒）
M MonthEnd 每月最后一个日历日
BM BusinessMonthEnd 每月最后一个工作日
BMS BusinessMonthBegin 每月第一个工作日
W-MON，W-TUE Week 从指定的星期几（MON，TUE，WED，THU，FRI，SAT，SUN）开始算起，每周
WOM-1MON，WOM-2MON… WeekOfMonth 产生每月第一，第二，第三或第四周的星期几，例如，WON-3FRI 表示每月第 3 个星期五
Q-JAN，Q-FEB QuarterEnd 对于指定月份（JAN，FEB，MAR，APR，MAY，JUN，JUL，AUG，SEP，OCT，NOV，DEC）结束的年度，每季度最后一月的最后一个日历日
date_range 默认会保留起始和结束时间戳的时间信息（如果有的话）：

pd.date_range(‘2012-05-02 12:56:31’, periods=5)
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 选项即可实现该功能：

pd.date_range(‘2012-05-02 12:56:31’, periods=5, normalize=True)
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 类表示：

from pandas.tseries.offsets import Hour, Minute
hour = Hour()
hour
传入一个整数即可定义偏移量的倍数：

four_hours = Hour(4)
four_hours
<4 * Hours>
一般来说，无需明确创建这样的对象，只需使用诸如 "H" 或 "4H" 这样的字符串别名即可。在基础频率前面放上一个整数即可创建倍数：

pd.date_range(‘2000-01-01’, ‘2000-01-02 23:59’, freq=‘4h’)
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’],
dtype=‘datetime64[ns]’, freq=‘4H’)
大部分偏移量对象都可通过加法进行连接：

Hour(2) + Minute(30)
<150 * Minutes>
同理，你也可以传入频率字符串（如 "2h30min"），这种字符串可以被高效地解析为等效的表达式：

pd.date_range(‘2000-01-01’, periods=10, freq=‘1h30min’)
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）。

表 11-4 列出了 pandas 中的频率代码和日期偏移量类。

笔记：用户可以根据实际需求自定义一些频率类以便提供 pandas 所没有的日期逻辑，但具体的细节超出了本书的范围。

WOM 日期
WOM（Week Of Month）是一种非常实用的频率类，它以 WOM 开头。它使你能获得诸如“每月第 3 个星期五”之类的日期：

rng = pd.date_range(‘2012-01-01’, ‘2012-09-01’, freq=‘WOM-3FRI’)
list(rng)
[Timestamp(‘2012-01-20 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-02-17 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-03-16 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-04-20 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-05-18 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-06-15 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-07-20 00:00:00’, freq=‘WOM-3FRI’),
Timestamp(‘2012-08-17 00:00:00’, freq=‘WOM-3FRI’)]
移动（超前和滞后）数据
移动（shifting）指的是沿着时间轴将数据前移或后移。Series 和 DataFrame 都有一个 shift 方法用于执行单纯的前移或后移操作，保持索引不变：

ts = pd.Series(np.random.randn(4),
index=pd.date_range(‘1/1/2000’, periods=4, freq=‘M’))
ts
2000-01-31 -0.287385
2000-02-29 1.622551
2000-03-31 1.491420
2000-04-30 -1.574550
Freq: M, dtype: float64
ts.shift(1)
2000-01-31 NaN
2000-02-29 -0.287385
2000-03-31 1.622551
2000-04-30 1.491420
Freq: M, dtype: float64
ts.shift(-2)
2000-01-31 1.49142
2000-02-29 -1.57455
2000-03-31 NaN
2000-04-30 NaN
Freq: M, dtype: float64
当我们这样进行移动时，就会在时间序列的前面或后面产生缺失数据。

shift 通常用于计算一个时间序列或多个时间序列（如 DataFrame 的列）中的百分比变化。可以这样表达：

ts / ts.shift(1) - 1
2000-01-31 NaN
2000-02-29 -6.645906
2000-03-31 -0.080818
2000-04-30 -2.055739
Freq: M, dtype: float64
由于单纯的移位操作不会修改索引，所以部分数据会被丢弃。因此，如果频率已知，则可以将其传给 shift 以便实现对时间戳进行位移而不是对数据进行简单位移：

ts.shift(2, freq=‘M’)
2000-03-31 -0.287385
2000-04-30 1.622551
2000-05-31 1.491420
2000-06-30 -1.574550
Freq: M, dtype: float64
这里还可以使用其他频率，于是你就能非常灵活地对数据进行超前和滞后处理了：

ts.shift(3, freq=‘D’)
2000-02-03 -0.287385
2000-03-03 1.622551
2000-04-03 1.491420
2000-05-03 -1.574550
dtype: float64
ts.shift(1, freq=‘90T’)
2000-01-31 01:30:00 -0.287385
2000-02-29 01:30:00 1.622551
2000-03-31 01:30:00 1.491420
2000-04-30 01:30:00 -1.574550
Freq: M, dtype: float64
通过偏移量对日期进行位移
pandas 的日期偏移量还可以用在 datetime 或 Timestamp 对象上：

from pandas.tseries.offsets import Day, MonthEnd
now = datetime(2011, 11, 17)
now + 3 * Day()
Timestamp(‘2011-11-20 00:00:00’)
如果加的是锚点偏移量（比如 MonthEnd），第一次增量会将原日期向前滚动到符合频率规则的下一个日期：

now + MonthEnd()
Timestamp(‘2011-11-30 00:00:00’)
now + MonthEnd(2)
Timestamp(‘2011-12-31 00:00:00’)
通过锚点偏移量的 rollforward 和 rollback 方法，可明确地将日期向前或向后“滚动”：

offset = MonthEnd()
offset.rollforward(now)
Timestamp(‘2011-11-30 00:00:00’)
offset.rollback(now)
Timestamp(‘2011-10-31 00:00:00’)
日期偏移量还有一个巧妙的用法，即结合 groupby 使用这两个“滚动”方法：

ts = pd.Series(np.random.randn(20),
index=pd.date_range(‘1/15/2000’, periods=20, freq=‘4d’))

ts
2000-01-15 0.279519
2000-01-19 1.309442
2000-01-23 -2.011374
2000-01-27 0.975700
2000-01-31 0.409972
2000-02-04 0.138767
2000-02-08 -0.136701
2000-02-12 -1.955546
2000-02-16 1.302017
2000-02-20 -0.580429
2000-02-24 1.347692
2000-02-28 1.006742
2000-03-03 -0.799835
2000-03-07 1.166547
2000-03-11 1.628751
2000-03-15 -0.637986
2000-03-19 -0.513706
2000-03-23 -0.189707
2000-03-27 1.415644
2000-03-31 0.729478
Freq: 4D, dtype: float64
ts.groupby(offset.rollforward).mean()
2000-01-31 0.192652
2000-02-29 0.160363
2000-03-31 0.349898
dtype: float64
当然，更简单、更快速地实现该功能的办法是使用 resample（11.6 小节将对此进行详细介绍）：

ts.resample(‘M’).mean()
2000-01-31 0.192652
2000-02-29 0.160363
2000-03-31 0.349898
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 中看到，也可以通过文档查看：

import pytz
pytz.common_timezones[-5:]
[‘US/Eastern’, ‘US/Hawaii’, ‘US/Mountain’, ‘US/Pacific’, ‘UTC’]
要从 pytz 中获取时区对象，使用 pytz.timezone 即可：

tz = pytz.timezone(‘America/New_York’)
tz
<DstTzInfo ‘America/New_York’ LMT-1 day, 19:04:00 STD>
pandas 中的方法既可以接受时区名也可以接受这些对象。

时区本地化和转换
默认情况下，pandas 中的时间序列是单纯（naive）的时区。看看下面这个时间序列：

rng = pd.date_range(‘3/9/2012 9:30’, periods=6, freq=‘D’)
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
2012-03-09 09:30:00 0.524571
2012-03-10 09:30:00 0.091110
2012-03-11 09:30:00 0.924881
2012-03-12 09:30:00 -1.313322
2012-03-13 09:30:00 0.487484
2012-03-14 09:30:00 -1.706168
Freq: D, dtype: float64
ts.index
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’)
其索引的 tz 字段为 None：

print(ts.index.tz)
None
可以用时区集生成日期范围：

pd.date_range(‘3/9/2012 9:30’, periods=10, freq=‘D’, tz=‘UTC’)
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 方法处理的：

ts
2012-03-09 09:30:00 0.524571
2012-03-10 09:30:00 0.091110
2012-03-11 09:30:00 0.924881
2012-03-12 09:30:00 -1.313322
2012-03-13 09:30:00 0.487484
2012-03-14 09:30:00 -1.706168
Freq: D, dtype: float64
ts_utc = ts.tz_localize(‘UTC’)
ts_utc
2012-03-09 09:30:00+00:00 0.524571
2012-03-10 09:30:00+00:00 0.091110
2012-03-11 09:30:00+00:00 0.924881
2012-03-12 09:30:00+00:00 -1.313322
2012-03-13 09:30:00+00:00 0.487484
2012-03-14 09:30:00+00:00 -1.706168
Freq: D, dtype: float64
ts_utc.index
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’)
一旦时间序列被本地化到某个特定时区，就可以用 tz_convert 将其转换到别的时区了：

ts_utc.tz_convert(‘America/New_York’)
2012-03-09 04:30:00-05:00 0.524571
2012-03-10 04:30:00-05:00 0.091110
2012-03-11 05:30:00-04:00 0.924881
2012-03-12 05:30:00-04:00 -1.313322
2012-03-13 05:30:00-04:00 0.487484
2012-03-14 05:30:00-04:00 -1.706168
Freq: D, dtype: float64
对于上面这种时间序列（它跨越了美国东部时区的夏令时转变期），我们可以将其本地化到 EST，然后转换为 UTC 或柏林时间：

ts_eastern = ts.tz_localize(‘America/New_York’)
ts_eastern.tz_convert(‘UTC’)
2012-03-09 14:30:00+00:00 0.524571
2012-03-10 14:30:00+00:00 0.091110
2012-03-11 13:30:00+00:00 0.924881
2012-03-12 13:30:00+00:00 -1.313322
2012-03-13 13:30:00+00:00 0.487484
2012-03-14 13:30:00+00:00 -1.706168
Freq: D, dtype: float64
ts_eastern.tz_convert(‘Europe/Berlin’)
2012-03-09 15:30:00+01:00 0.524571
2012-03-10 15:30:00+01:00 0.091110
2012-03-11 14:30:00+01:00 0.924881
2012-03-12 14:30:00+01:00 -1.313322
2012-03-13 14:30:00+01:00 0.487484
2012-03-14 14:30:00+01:00 -1.706168
Freq: D, dtype: float64
tz_localize 和 tz_convert 也是 DatetimeIndex 的实例方法：

ts.index.tz_localize(‘Asia/Shanghai’)
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），并从一个时区转换到另一个时区：

stamp = pd.Timestamp(‘2011-03-12 04:00’)

stamp_utc = stamp.tz_localize(‘utc’)
stamp_utc.tz_convert(‘America/New_York’)
Timestamp(‘2011-03-11 23:00:00-0500’, tz=‘America/New_York’)
在创建 Timestamp 时，还可以传入一个时区信息：

stamp_moscow = pd.Timestamp(‘2011-03-12 04:00’, tz=‘Europe/Moscow’)
stamp_moscow
Timestamp(‘2011-03-12 04:00:00+0300’, tz=‘Europe/Moscow’)
时区意识型 Timestamp 对象在内部保存了一个 UTC 时间戳值（自 UNIX 纪元（1970 年 1 月 1 日）算起的纳秒数）。这个 UTC 值在时区转换过程中是不会发生变化的：

stamp_utc.value
1299902400000000000
stamp_utc.tz_convert(‘America/New_York’).value
1299902400000000000
当使用 pandas 的 DateOffset 对象执行时间算术运算时，运算过程会自动关注是否存在夏令时转变期。这里，我们创建了在 DST 转变之前的时间戳。首先，来看夏令时转变前的 30 分钟：

from pandas.tseries.offsets import Hour

stamp = pd.Timestamp(‘2012-03-12 01:30’, tz=‘US/Eastern’)

stamp
Timestamp(‘2012-03-12 01:30:00-0400’, tz=‘US/Eastern’)
stamp + Hour()
Timestamp(‘2012-03-12 02:30:00-0400’, tz=‘US/Eastern’)
然后，夏令时转变前 90 分钟：

stamp = pd.Timestamp(‘2012-11-04 00:30’, tz=‘US/Eastern’)

stamp

Timestamp(‘2012-11-04 00:30:00-0400’, tz=‘US/Eastern’)
stamp + 2 * Hour()
Timestamp(‘2012-11-04 01:30:00-0500’, tz=‘US/Eastern’)
不同时区之间的运算
如果两个时间序列的时区不同，在将它们合并到一起时，最终结果就会是 UTC。由于时间戳其实是以 UTC 存储的，所以这是一个很简单的运算，并不需要发生任何转换：

rng = pd.date_range(‘3/7/2012 9:30’, periods=10, freq=‘B’)
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
2012-03-07 09:30:00 1.074193
2012-03-08 09:30:00 0.870584
2012-03-09 09:30:00 -0.221292
2012-03-12 09:30:00 -0.424824
2012-03-13 09:30:00 -2.647929
2012-03-14 09:30:00 -0.141948
2012-03-15 09:30:00 1.255836
2012-03-16 09:30:00 -1.250273
2012-03-19 09:30:00 -0.519711
2012-03-20 09:30:00 0.833019
Freq: B, dtype: float64
ts1 = ts[:7].tz_localize(‘Europe/London’)
ts2 = ts1[2:].tz_convert(‘Europe/Moscow’)
result = ts1 + ts2
result.index
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’)
时期及其算术运算
时期（period）表示的是时间区间，比如数日、数月、数季、数年等。Period 类所表示的就是这种数据类型，其构造函数需要用到一个字符串或整数，以及表 11-4 中的频率：

p = pd.Period(2007, freq=‘A-DEC’)
p
Period(‘2007’, ‘A-DEC’)
这里，这个 Period 对象表示的是从 2007 年 1 月 1 日到 2007 年 12 月 31 日之间的整段时间。只需对 Period 对象加上或减去一个整数即可达到根据其频率进行位移的效果：

p + 5

Period(‘2012’, ‘A-DEC’)
p - 2
Period(‘2005’, ‘A-DEC’)
如果两个 Period 对象拥有相同的频率，则它们的差就是它们之间的单位数量：

pd.Period(‘2014’, freq=‘A-DEC’) - p
7
period_range 函数可用于创建规则的时期范围：

rng = pd.period_range(‘2000-01-01’, ‘2000-06-30’, freq=‘M’)
rng
PeriodIndex([‘2000-01’, ‘2000-02’, ‘2000-03’, ‘2000-04’, ‘2000-05’, ‘2000-06’], dtype=‘period[M]’, freq=‘M’)
PeriodIndex 类保存了一组 Period，它可以在任何 pandas 数据结构中被用作轴索引：

pd.Series(np.random.randn(6), index=rng)
2000-01 0.047430
2000-02 -0.499139
2000-03 0.647101
2000-04 0.073256
2000-05 -0.287499
2000-06 -0.557552
Freq: M, dtype: float64
如果你有一个字符串数组，你也可以使用 PeriodIndex 类：

values = [‘2001Q3’, ‘2002Q2’, ‘2003Q1’]
index = pd.PeriodIndex(values, freq=‘Q-DEC’)
index
PeriodIndex([‘2001Q3’, ‘2002Q2’, ‘2003Q1’], dtype=‘period[Q-DEC]’, freq=‘Q-DEC’)
时期的频率转换
Period 和 PeriodIndex 对象都可以通过其 asfreq 方法被转换成别的频率。假设我们有一个年度时期，希望将其转换为当年年初或年末的一个月度时期。该任务非常简单：

p = pd.Period(‘2007’, freq=‘A-DEC’)
p
Period(‘2007’, ‘A-DEC’)
p.asfreq(‘M’, how=‘start’)
Period(‘2007-01’, ‘M’)
p.asfreq(‘M’, how=‘end’)
Period(‘2007-12’, ‘M’)
你可以将 Period(‘2007’,‘A-DEC’) 看做一个被划分为多个月度时期的时间段中的游标。图 11-1 对此进行了说明。对于一个不以 12 月结束的财政年度，月度子时期的归属情况就不一样了：

p = pd.Period(‘2007’, freq=‘A-JUN’)
p
Period(‘2007’, ‘A-JUN’)
p.asfreq(‘M’, ‘start’)
Period(‘2006-07’, ‘M’)
p.asfreq(‘M’, ‘end’)
Period(‘2007-06’, ‘M’)
在这里插入图片描述

在将高频率转换为低频率时，超时期（superperiod）是由子时期（subperiod）所属的位置决定的。例如，在 A-JUN 频率中，月份“2007 年 8 月”实际上是属于周期“2008 年”的：

p = pd.Period(‘Aug-2007’, ‘M’)
p.asfreq(‘A-JUN’)
Period(‘2008’, ‘A-JUN’)
完整的 PeriodIndex 或 TimeSeries 的频率转换方式也是如此：

rng = pd.period_range(‘2006’, ‘2009’, freq=‘A-DEC’)
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
2006 1.084452
2007 0.070688
2008 1.366524
2009 1.141092
Freq: A-DEC, dtype: float64
ts.asfreq(‘M’, how=‘start’)
2006-01 1.084452
2007-01 0.070688
2008-01 1.366524
2009-01 1.141092
Freq: M, dtype: float64
这里，根据年度时期的第一个月，每年的时期被取代为每月的时期。如果我们想要每年的最后一个工作日，我们可以使用“B”频率，并指明想要该时期的末尾：

ts.asfreq(‘B’, how=‘end’)
2006-12-29 1.084452
2007-12-31 0.070688
2008-12-31 1.366524
2009-12-31 1.141092
Freq: B, dtype: float64
按季度计算的时期频率
季度型数据在会计、金融等领域中很常见。许多季度型数据都会涉及“财年末”的概念，通常是一年 12 个月中某月的最后一个日历日或工作日。就这一点来说，时期 "2012Q4" 根据财年末的不同会有不同的含义。pandas 支持 12 种可能的季度型频率，即 Q-JAN 到 Q-DEC：

p = pd.Period(‘2012Q4’, freq=‘Q-JAN’)
p
Period(‘2012Q4’, ‘Q-JAN’)
在以 1 月结束的财年中，2012Q4 是从 11 月到 1 月（将其转换为日型频率就明白了）。图 11-2 对此进行了说明：

p.asfreq(‘D’, ‘start’)
Period(‘2011-11-01’, ‘D’)
p.asfreq(‘D’, ‘end’)
Period(‘2012-01-31’, ‘D’)
在这里插入图片描述

因此，Period 之间的算术运算会非常简单。例如，要获取该季度倒数第二个工作日下午 4 点的时间戳，你可以这样：

p4pm = (p.asfreq(‘B’, ‘e’) - 1).asfreq(‘T’, ‘s’) + 16 * 60

p4pm
Period(‘2012-01-30 16:00’, ‘T’)
period_range 可用于生成季度型范围。季度型范围的算术运算也跟上面是一样的：

rng = pd.period_range(‘2011Q3’, ‘2012Q4’, freq=‘Q-JAN’)
ts = pd.Series(np.arange(len(rng)), index=rng)

ts
2011Q3 0
2011Q4 1
2012Q1 2
2012Q2 3
2012Q3 4
2012Q4 5
Freq: Q-JAN, dtype: int64
new_rng = (rng.asfreq(‘B’, ‘e’) - 1).asfreq(‘T’, ‘s’) + 16 * 60

ts.index = new_rng.to_timestamp()
ts
2010-10-28 16:00:00 0
2011-01-28 16:00:00 1
2011-04-28 16:00:00 2
2011-07-28 16:00:00 3
2011-10-28 16:00:00 4
2012-01-30 16:00:00 5
dtype: int64
将 Timestamp 转换为 Period（及其反向过程）
通过使用 to_period 方法，可以将由时间戳索引的 Series 和 DataFrame 对象转换为以时期索引：

rng = pd.date_range(‘2000-01-01’, periods=3, freq=‘M’)

ts = pd.Series(np.random.randn(3), index=rng)
ts
2000-01-31 0.711251
2000-02-29 -0.583942
2000-03-31 -0.374504
Freq: M, dtype: float64
pts = ts.to_period()
pts
2000-01 0.711251
2000-02 -0.583942
2000-03 -0.374504
Freq: M, dtype: float64
由于时期指的是非重叠时间区间，因此对于给定的频率，一个时间戳只能属于一个时期。新 PeriodIndex 的频率默认是从时间戳推断而来的，你也可以指定任何别的频率。结果中允许存在重复时期：

rng = pd.date_range(‘1/29/2000’, periods=6, freq=‘D’)
ts2 = pd.Series(np.random.randn(6), index=rng)
ts2
2000-01-29 0.452325
2000-01-30 -0.796592
2000-01-31 -1.288143
2000-02-01 -0.342011
2000-02-02 -0.724164
2000-02-03 1.225062
Freq: D, dtype: float64
ts2.to_period(‘M’)
2000-01 0.452325
2000-01 -0.796592
2000-01 -1.288143
2000-02 -0.342011
2000-02 -0.724164
2000-02 1.225062
Freq: M, dtype: float64
要转换回时间戳，使用 to_timestamp 即可：

pts = ts2.to_period()
pts
2000-01-29 0.452325
2000-01-30 -0.796592
2000-01-31 -1.288143
2000-02-01 -0.342011
2000-02-02 -0.724164
2000-02-03 1.225062
Freq: D, dtype: float64
pts.to_timestamp(how=‘end’)
2000-01-29 0.452325
2000-01-30 -0.796592
2000-01-31 -1.288143
2000-02-01 -0.342011
2000-02-02 -0.724164
2000-02-03 1.225062
Freq: D, dtype: float64
通过数组创建 PeriodIndex
固定频率的数据集通常会将时间信息分开存放在多个列中。例如，在下面这个宏观经济数据集中，年度和季度就分别存放在不同的列中：

data = pd.read_csv(‘examples/macrodata.csv’)
data.head()

year	quarter	realgdp	realcons	realinv	realgovt	realdpi	cpi	m1	tbilrate	unemp	pop	infl	realint

0 1959.0 1.0 2710.349 1707.4 286.898 470.045 1886.9 28.98 139.7 2.82 5.8 177.146 0.00 0.00
1 1959.0 2.0 2778.801 1733.7 310.859 481.301 1919.7 29.15 141.7 3.08 5.1 177.830 2.34 0.74
2 1959.0 3.0 2775.488 1751.8 289.226 491.260 1916.4 29.35 140.5 3.82 5.3 178.657 2.74 1.09
3 1959.0 4.0 2785.204 1753.7 299.356 484.052 1931.3 29.37 140.0 4.33 5.6 179.386 0.27 4.06
4 1960.0 1.0 2847.699 1770.5 331.722 462.199 1955.5 29.54 139.6 3.50 5.2 180.007 2.31 1.19
data.year.head()
0 1959.0
1 1959.0
2 1959.0
3 1959.0
4 1960.0
Name: year, dtype: float64
data.quarter.head()
0 1.0
1 2.0
2 3.0
3 4.0
4 1.0
Name: quarter, dtype: float64
通过将这些数组以及一个频率传入 PeriodIndex，就可以将它们合并成 DataFrame 的一个索引：

index = pd.PeriodIndex(year=data.year, quarter=data.quarter, freq=‘Q-DEC’)
index
PeriodIndex([‘1959Q1’, ‘1959Q2’, ‘1959Q3’, ‘1959Q4’, ‘1960Q1’, ‘1960Q2’,
‘1960Q3’, ‘1960Q4’, ‘1961Q1’, ‘1961Q2’,
…
‘2007Q2’, ‘2007Q3’, ‘2007Q4’, ‘2008Q1’, ‘2008Q2’, ‘2008Q3’,
‘2008Q4’, ‘2009Q1’, ‘2009Q2’, ‘2009Q3’],
dtype=‘period[Q-DEC]’, length=203, freq=‘Q-DEC’)
data.index = index
data.infl.head()
1959Q1 0.00
1959Q2 2.34
1959Q3 2.74
1959Q4 0.27
1960Q1 2.31
Freq: Q-DEC, Name: infl, dtype: float64
重采样及频率转换
重采样（resampling）指的是将时间序列从一个频率转换到另一个频率的处理过程。将高频率数据聚合到低频率称为降采样（downsampling），而将低频率数据转换到高频率则称为升采样（upsampling）。并不是所有的重采样都能被划分到这两个大类中。例如，将 W-WED（每周三）转换为 W-FRI 既不是降采样也不是升采样。

pandas 对象都带有一个 resample 方法，它是各种频率转换工作的主力函数。resample 有一个类似于 groupby 的 API，调用 resample 可以分组数据，然后会调用一个聚合函数：

rng = pd.date_range(‘2000-01-01’, periods=100, freq=‘D’)
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts.sample(5)
2000-02-14 -0.168019
2000-02-05 -1.568326
2000-04-05 2.108838
2000-01-02 -0.302924
2000-02-20 0.681909
dtype: float64
ts.resample(‘M’).mean()
2000-01-31 0.149947
2000-02-29 -0.241514
2000-03-31 0.109753
2000-04-30 0.860072
Freq: M, dtype: float64
ts.resample(‘M’, kind=‘period’).mean()
2000-01 0.149947
2000-02 -0.241514
2000-03 0.109753
2000-04 0.860072
Freq: M, dtype: float64
resample 是一个灵活高效的方法，可用于处理非常大的时间序列。我将通过一系列的示例说明其用法。表 11-5 总结它的一些选项。

降采样
将数据聚合到规律的低频率是一件非常普通的时间序列处理任务。待聚合的数据不必拥有固定的频率，期望的频率会自动定义聚合的面元边界，这些面元用于将时间序列拆分为多个片段。例如，要转换到月度频率（‘M’或’BM’），数据需要被划分到多个单月时间段中。各时间段都是半开放的。一个数据点只能属于一个时间段，所有时间段的并集必须能组成整个时间帧。在用 resample 对数据进行降采样时，需要考虑两样东西：

各区间哪边是闭合的。
如何标记各个聚合面元，用区间的开头还是末尾。
为了说明，我们来看一些“1 分钟”数据：

rng = pd.date_range(‘2000-01-01’, periods=12, freq=‘T’)

ts = pd.Series(np.arange(12), index=rng)
ts
2000-01-01 00:00:00 0
2000-01-01 00:01:00 1
2000-01-01 00:02:00 2
2000-01-01 00:03:00 3
2000-01-01 00:04:00 4
2000-01-01 00:05:00 5
2000-01-01 00:06:00 6
2000-01-01 00:07:00 7
2000-01-01 00:08:00 8
2000-01-01 00:09:00 9
2000-01-01 00:10:00 10
2000-01-01 00:11:00 11
Freq: T, dtype: int64
假设你想要通过求和的方式将这些数据聚合到“5 分钟”块中：

ts.resample(‘5min’, closed=‘right’).sum()
1999-12-31 23:55:00 0
2000-01-01 00:00:00 15
2000-01-01 00:05:00 40
2000-01-01 00:10:00 11
Freq: 5T, dtype: int64
传入的频率将会以“5 分钟”的增量定义面元边界。默认情况下，面元的右边界是包含的，因此 00:00 到 00:05 的区间中是包含 00:05 的。传入 closed=’left’会让区间以左边界闭合：

ts.resample(‘5min’, closed=‘left’).sum()
2000-01-01 00:00:00 10
2000-01-01 00:05:00 35
2000-01-01 00:10:00 21
Freq: 5T, dtype: int64
图 11-3 说明了“1 分钟”数据被转换为“5 分钟”数据的处理过程。

在这里插入图片描述

最后，你可能希望对结果索引做一些位移，比如从右边界减去一秒以便更容易明白该时间戳到底表示的是哪个区间。只需通过 loffset 设置一个字符串或日期偏移量即可实现这个目的：

ts.resample(‘5min’, closed=‘right’,
label=‘right’, loffset=‘-1s’).sum()
1999-12-31 23:59:59 0
2000-01-01 00:04:59 15
2000-01-01 00:09:59 40
2000-01-01 00:14:59 11
Freq: 5T, dtype: int64
此外，也可以通过调用结果对象的 shift 方法来实现该目的，这样就不需要设置 loffset 了。

OHLC 重采样
金融领域中有一种无所不在的时间序列聚合方式，即计算各面元的四个值：第一个值（open，开盘）、最后一个值（close，收盘）、最大值（high，最高）以及最小值（low，最低）。传入 how=’ohlc’即可得到一个含有这四种聚合值的 DataFrame。整个过程很高效，只需一次扫描即可计算出结果：

ts.resample(‘5min’).ohlc()

open	high	low	close

2000-01-01 00:00:00 0 4 0 4
2000-01-01 00:05:00 5 9 5 9
2000-01-01 00:10:00 10 11 10 11
升采样和插值
在将数据从低频率转换到高频率时，就不需要聚合了。我们来看一个带有一些周型数据的 DataFrame：

frame = pd.DataFrame(np.random.randn(2, 4),
index=pd.date_range(‘1/1/2000’, periods=2,
freq=‘W-WED’),
columns=[‘Colorado’, ‘Texas’, ‘New York’, ‘Ohio’])

frame

Colorado	Texas	New York	Ohio

2000-01-05 -0.189962 0.027335 1.789346 0.064401
2000-01-12 -1.473663 0.720343 -0.301249 -0.062475
当你对这个数据进行聚合，每组只有一个值，这样就会引入缺失值。我们使用 asfreq 方法转换成高频，不经过聚合：

df_daily = frame.resample(‘D’).asfreq()
df_daily

Colorado	Texas	New York	Ohio

2000-01-05 -0.189962 0.027335 1.789346 0.064401
2000-01-06 NaN NaN NaN NaN
2000-01-07 NaN NaN NaN NaN
2000-01-08 NaN NaN NaN NaN
2000-01-09 NaN NaN NaN NaN
2000-01-10 NaN NaN NaN NaN
2000-01-11 NaN NaN NaN NaN
2000-01-12 -1.473663 0.720343 -0.301249 -0.062475
假设你想要用前面的周型值填充“非星期三”。resampling 的填充和插值方式跟 fillna 和 reindex 的一样：

frame.resample(‘D’).ffill()

Colorado	Texas	New York	Ohio

2000-01-05 -0.189962 0.027335 1.789346 0.064401
2000-01-06 -0.189962 0.027335 1.789346 0.064401
2000-01-07 -0.189962 0.027335 1.789346 0.064401
2000-01-08 -0.189962 0.027335 1.789346 0.064401
2000-01-09 -0.189962 0.027335 1.789346 0.064401
2000-01-10 -0.189962 0.027335 1.789346 0.064401
2000-01-11 -0.189962 0.027335 1.789346 0.064401
2000-01-12 -1.473663 0.720343 -0.301249 -0.062475
同样，这里也可以只填充指定的时期数（目的是限制前面的观测值的持续使用距离）：

frame.resample(‘D’).ffill(limit=2)

Colorado	Texas	New York	Ohio

2000-01-05 -0.189962 0.027335 1.789346 0.064401
2000-01-06 -0.189962 0.027335 1.789346 0.064401
2000-01-07 -0.189962 0.027335 1.789346 0.064401
2000-01-08 NaN NaN NaN NaN
2000-01-09 NaN NaN NaN NaN
2000-01-10 NaN NaN NaN NaN
2000-01-11 NaN NaN NaN NaN
2000-01-12 -1.473663 0.720343 -0.301249 -0.062475
注意，新的日期索引完全没必要跟旧的重叠：

frame.resample(‘W-THU’).ffill()

Colorado	Texas	New York	Ohio

2000-01-06 -0.189962 0.027335 1.789346 0.064401
2000-01-13 -1.473663 0.720343 -0.301249 -0.062475
通过时期进行重采样
对那些使用时期索引的数据进行重采样与时间戳很像：

frame = pd.DataFrame(np.random.randn(24, 4),
index=pd.period_range(‘1-2000’, ‘12-2001’,
freq=‘M’),
columns=[‘Colorado’, ‘Texas’, ‘New York’, ‘Ohio’])

frame[:5]

Colorado	Texas	New York	Ohio

2000-01 -0.913858 0.940064 -0.979250 -0.373118
2000-02 1.153720 1.009668 -1.412601 -2.252794
2000-03 -1.811461 1.077497 -0.012584 0.978731
2000-04 0.236256 0.747518 -0.579942 0.508246
2000-05 -0.913383 0.578177 -0.274615 0.985622
annual_frame = frame.resample(‘A-DEC’).mean()
annual_frame

Colorado	Texas	New York	Ohio

2000 0.192190 0.17422 -0.231415 0.167097
2001 0.028655 -0.06748 -0.239070 0.012785
升采样要稍微麻烦一些，因为你必须决定在新频率中各区间的哪端用于放置原来的值，就像 asfreq 方法那样。convention 参数默认为’start’，也可设置为’end’：

annual_frame.resample(‘Q-DEC’).ffill()

Colorado	Texas	New York	Ohio

2000Q1 0.192190 0.17422 -0.231415 0.167097
2000Q2 0.192190 0.17422 -0.231415 0.167097
2000Q3 0.192190 0.17422 -0.231415 0.167097
2000Q4 0.192190 0.17422 -0.231415 0.167097
2001Q1 0.028655 -0.06748 -0.239070 0.012785
2001Q2 0.028655 -0.06748 -0.239070 0.012785
2001Q3 0.028655 -0.06748 -0.239070 0.012785
2001Q4 0.028655 -0.06748 -0.239070 0.012785
annual_frame.resample(‘Q-DEC’, convention=‘end’).ffill()

Colorado	Texas	New York	Ohio

在降采样中，目标频率必须是源频率的子时期（subperiod）。
在升采样中，目标频率必须是源频率的超时期（superperiod）。
如果不满足这些条件，就会引发异常。这主要影响的是按季、年、周计算的频率。例如，由 Q-MAR 定义的时间区间只能升采样为 A-MAR、A-JUN、A-SEP、A-DEC 等：

annual_frame.resample(‘Q-MAR’).ffill()

Colorado	Texas	New York	Ohio

2000Q4 0.192190 0.17422 -0.231415 0.167097
2001Q1 0.192190 0.17422 -0.231415 0.167097
2001Q2 0.192190 0.17422 -0.231415 0.167097
2001Q3 0.192190 0.17422 -0.231415 0.167097
2001Q4 0.028655 -0.06748 -0.239070 0.012785
2002Q1 0.028655 -0.06748 -0.239070 0.012785
2002Q2 0.028655 -0.06748 -0.239070 0.012785
2002Q3 0.028655 -0.06748 -0.239070 0.012785
移动窗口函数
在移动窗口（可以带有指数衰减权数）上计算的各种统计函数也是一类常见于时间序列的数组变换。这样可以圆滑噪音数据或断裂数据。我将它们称为移动窗口函数（moving window function），其中还包括那些窗口不定长的函数（如指数加权移动平均）。跟其他统计函数一样，移动窗口函数也会自动排除缺失值。

开始之前，我们加载一些时间序列数据，将其重采样为工作日频率：

close_px_all = pd.read_csv(‘examples/stock_px_2.csv’,
parse_dates=True, index_col=0)
close_px_all[:9]

AAPL	MSFT	XOM	SPX

2003-01-02 7.40 21.11 29.22 909.03
2003-01-03 7.45 21.14 29.24 908.59
2003-01-06 7.45 21.52 29.96 929.01
2003-01-07 7.43 21.93 28.95 922.93
2003-01-08 7.28 21.31 28.83 909.93
2003-01-09 7.34 21.93 29.44 927.57
2003-01-10 7.36 21.97 29.03 927.57
2003-01-13 7.32 22.16 28.91 926.26
2003-01-14 7.30 22.39 29.17 931.66
close_px = close_px_all’AAPL’, ’MSFT’, ’XOM’
close_px = close_px.resample(‘B’).ffill()
close_px[:9]

AAPL	MSFT	XOM

2003-01-02 7.40 21.11 29.22
2003-01-03 7.45 21.14 29.24
2003-01-06 7.45 21.52 29.96
2003-01-07 7.43 21.93 28.95
2003-01-08 7.28 21.31 28.83
2003-01-09 7.34 21.93 29.44
2003-01-10 7.36 21.97 29.03
2003-01-13 7.32 22.16 28.91
2003-01-14 7.30 22.39 29.17
现在引入 rolling 运算符，它与 resample 和 groupby 很像。可以在 TimeSeries 或 DataFrame 以及一个 window（表示期数，见图 11-4）上调用它：

苹果公司股价的 250 日均线

close_px.AAPL.plot()
close_px.AAPL.rolling(250).mean().plot()
<matplotlib.axes._subplots.AxesSubplot at 0x7f12a3c3fc50>
在这里插入图片描述

表达式 rolling(250) 与 groupby 很像，但不是对其进行分组，而是创建一个按照 250 天分组的滑动窗口对象。然后，我们就得到了苹果公司股价的 250 天的移动窗口。

默认情况下，rolling 函数需要窗口中所有的值为非 NA 值。可以修改该行为以解决缺失数据的问题。其实，在时间序列开始处尚不足窗口期的那些数据就是个特例（见图 11-5）：

appl_std250 = close_px.AAPL.rolling(250, min_periods=10).std()
appl_std250[5:12]
2003-01-09 NaN
2003-01-10 NaN
2003-01-13 NaN
2003-01-14 NaN
2003-01-15 0.077496
2003-01-16 0.074760
2003-01-17 0.112368
Freq: B, Name: AAPL, dtype: float64
appl_std250.plot()
<matplotlib.axes._subplots.AxesSubplot at 0x7f12a3b98320>
在这里插入图片描述

要计算扩展窗口平均（expanding window mean），可以使用 expanding 而不是 rolling。“扩展”意味着，从时间序列的起始处开始窗口，增加窗口直到它超过所有的序列。apple_std250 时间序列的扩展窗口平均如下所示：

expanding_mean = appl_std250.expanding().mean()

对 DataFrame 调用 rolling_mean（以及与之类似的函数）会将转换应用到所有的列上（见图 11-6）：

close_px.rolling(60).mean().plot(logy=True)

<matplotlib.axes._subplots.AxesSubplot at 0x7f12a3aaecc0>
在这里插入图片描述

rolling 函数也可以接受一个指定固定大小时间补偿字符串，而不是一组时期。这样可以方便处理不规律的时间序列。这些字符串也可以传递给 resample。例如，我们可以计算 20 天的滚动均值，如下所示

close_px.rolling(‘20D’).mean()

AAPL	MSFT	XOM

2003-01-02 7.400000 21.110000 29.220000
2003-01-03 7.425000 21.125000 29.230000
2003-01-06 7.433333 21.256667 29.473333
2003-01-07 7.432500 21.425000 29.342500
2003-01-08 7.402000 21.402000 29.240000
2003-01-09 7.391667 21.490000 29.273333
2003-01-10 7.387143 21.558571 29.238571
2003-01-13 7.378750 21.633750 29.197500
2003-01-14 7.370000 21.717778 29.194444
2003-01-15 7.355000 21.757000 29.152000
2003-01-16 7.350909 21.756364 29.129091
2003-01-17 7.325833 21.628333 29.085000
2003-01-20 7.304615 21.520000 29.047692
2003-01-21 7.283571 21.423571 28.968571
2003-01-22 7.250714 21.347143 28.851429
2003-01-23 7.225000 21.304286 28.728571
2003-01-24 7.203333 21.190000 28.608667
2003-01-27 7.160000 20.980000 28.316429
2003-01-28 7.160714 20.827857 28.178571
2003-01-29 7.170000 20.662143 28.067143
2003-01-30 7.155714 20.446429 27.948571
2003-01-31 7.157333 20.326667 27.960667
2003-02-03 7.147857 19.959286 27.846429
2003-02-04 7.153571 19.707857 27.828571
2003-02-05 7.147143 19.472143 27.772143
2003-02-06 7.159286 19.358571 27.720000
2003-02-07 7.153333 19.288000 27.716000
2003-02-10 7.172857 19.110714 27.647857
2003-02-11 7.190000 18.982857 27.654286
2003-02-12 7.197857 18.819286 27.625714
… … … …
2011-09-05 375.711429 25.276429 72.607857
2011-09-06 375.661429 25.295000 72.392857
2011-09-07 376.938571 25.390000 72.586429
2011-09-08 378.946429 25.545000 72.802143
2011-09-09 378.848667 25.558000 72.682667
2011-09-12 380.902143 25.754286 72.731429
2011-09-13 381.505000 25.835714 72.596429
2011-09-14 382.617857 25.973571 72.658571
2011-09-15 383.287857 26.097857 72.756429
2011-09-16 384.435333 26.166000 72.876000
2011-09-19 385.585714 26.259286 72.772143
2011-09-20 387.630000 26.286429 72.771429
2011-09-21 389.852143 26.270714 72.662857
2011-09-22 391.835714 26.217857 72.455714
2011-09-23 392.666667 26.140667 72.246000
2011-09-26 395.670000 26.160000 72.294286
2011-09-27 396.765000 26.136429 72.241429
2011-09-28 397.684286 26.090714 72.187857
2011-09-29 398.619286 26.070000 72.392857
2011-09-30 397.466000 25.991333 72.408667
2011-10-03 398.002143 25.890714 72.413571
2011-10-04 396.802143 25.807857 72.427143
2011-10-05 395.751429 25.729286 72.422857
2011-10-06 394.099286 25.673571 72.375714
2011-10-07 392.479333 25.712000 72.454667
2011-10-10 389.351429 25.602143 72.527857
2011-10-11 388.505000 25.674286 72.835000
2011-10-12 388.531429 25.810000 73.400714
2011-10-13 388.826429 25.961429 73.905000
2011-10-14 391.038000 26.048667 74.185333
2292 rows × 3 columns

指数加权函数
另一种使用固定大小窗口及相等权数观测值的办法是，定义一个衰减因子（decay factor）常量，以便使近期的观测值拥有更大的权数。衰减因子的定义方式有很多，比较流行的是使用时间间隔（span），它可以使结果兼容于窗口大小等于时间间隔的简单移动窗口（simple moving window）函数。

由于指数加权统计会赋予近期的观测值更大的权数，因此相对于等权统计，它能“适应”更快的变化。

除了 rolling 和 expanding，pandas 还有 ewm 运算符。下面这个例子对比了苹果公司股价的 30 日移动平均和 span=30 的指数加权移动平均（如图 11-7 所示）

aapl_px = close_px.AAPL[‘2006’:‘2007’]

ma60 = aapl_px.rolling(30, min_periods=20).mean()

ewma60 = aapl_px.ewm(span=30).mean()
import matplotlib.pyplot as plt
ma60.plot(style=‘k–’, label=‘Simple MA’)
ewma60.plot(style=‘k-’, label=‘EW MA’)
plt.legend()

<matplotlib.legend.Legend at 0x7f12a388a860>
在这里插入图片描述

二元移动窗口函数
有些统计运算（如相关系数和协方差）需要在两个时间序列上执行。例如，金融分析师常常对某只股票对某个参考指数（如标准普尔 500 指数）的相关系数感兴趣。要进行说明，我们先计算我们感兴趣的时间序列的百分数变化：

spx_px = close_px_all[‘SPX’]

spx_rets = spx_px.pct_change()

returns = close_px.pct_change()
调用 rolling 之后，corr 聚合函数开始计算与 spx_rets 滚动相关系数（结果见图 11-8）：

corr = returns.AAPL.rolling(125, min_periods=100).corr(spx_rets)

corr.plot()
<matplotlib.axes._subplots.AxesSubplot at 0x7f12a350a6d8>
在这里插入图片描述

假设你想要一次性计算多只股票与标准普尔 500 指数的相关系数。虽然编写一个循环并新建一个 DataFrame 不是什么难事，但比较啰嗦。其实，只需传入一个 TimeSeries 和一个 DataFrame，rolling_corr 就会自动计算 TimeSeries（本例中就是 spx_rets）与 DataFrame 各列的相关系数。结果如图 11-9 所示：

corr = returns.rolling(125, min_periods=100).corr(spx_rets)
corr.plot()
<matplotlib.axes._subplots.AxesSubplot at 0x7f12a3839b38>
在这里插入图片描述

用户定义的移动窗口函数
rolling_apply 函数使你能够在移动窗口上应用自己设计的数组函数。唯一要求的就是：该函数要能从数组的各个片段中产生单个值（即约简）。比如说，当我们用 rolling(…).quantile(q) 计算样本分位数时，可能对样本中特定值的百分等级感兴趣。scipy.stats.percentileofscore 函数就能达到这个目的（结果见图 11-10）：

from scipy.stats import percentileofscore
score_at_2percent = lambda x: percentileofscore(x, 0.02)
#AAPL 2% 回报率的百分等级（一年窗口期）
result = returns.AAPL.rolling(250).apply(score_at_2percent)
result.plot()
/root/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Currently, ‘apply’ passes the values as ndarrays to the applied function. In the future, this will change to passing it as Series objects. You need to specify ‘raw=True’ to keep the current behaviour, and you can pass ‘raw=False’ to silence this warning
"""Entry point for launching an IPython kernel.

<matplotlib.axes._subplots.AxesSubplot at 0x7f12a11c8dd8>
在这里插入图片描述

如果你没安装 SciPy，可以使用 conda 或 pip 安装。

总结
与前面章节接触的数据相比，时间序列数据要求不同类型的分析和数据转换工具。

在接下来的章节中，我们将学习一些高级的 pandas 方法和如何开始使用建模库 statsmodels 和 scikit-learn。