《利用Python进行数据分析·第2版》第11章（上） 时间序列

作者：SeanCheney   Python爱好者社区专栏作者

简书专栏：https://www.jianshu.com/u/130f76596b02

前文传送门：

时间序列（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）是用得最多的数据类型：

In [10]: from datetime import datetime In [11]: now = datetime.now() In [12]: now Out[12]: datetime.datetime(2017, 9, 25, 14, 5, 52, 72973) In [13]: now.year, now.month, now.day Out[13]: (2017, 9, 25)

datetime以毫秒形式存储日期和时间。timedelta表示两个datetime对象之间的时间差：

In [14]: delta = datetime(2011, 1, 7) - datetime(2008, 6, 24, 8, 15) In [15]: delta Out[15]: datetime.timedelta(926, 56700) In [16]: delta.days Out[16]: 926 In [17]: delta.seconds Out[17]: 56700

可以给datetime对象加上（或减去）一个或多个timedelta，这样会产生一个新对象：

In [18]: from datetime import timedelta In [19]: start = datetime(2011, 1, 7) In [20]: start + timedelta(12) Out[20]: datetime.datetime(2011, 1, 19, 0, 0) In [21]: start - 2 * timedelta(12) Out[21]: datetime.datetime(2010, 12, 14, 0, 0)

datetime模块中的数据类型参见表10-1。虽然本章主要讲的是pandas数据类型和高级时间序列处理，但你肯定会在Python的其他地方遇到有关datetime的数据类型。

表11-1 datetime模块中的数据类型

tzinfo  存储时区信息的基本类型

字符串和datetime的相互转换

利用str或strftime方法（传入一个格式化字符串），datetime对象和pandas的Timestamp对象（稍后就会介绍）可以被格式化为字符串：

In [22]: stamp = datetime(2011, 1, 3) In [23]: str(stamp) Out[23]: '2011-01-03 00:00:00' In [24]: stamp.strftime('%Y-%m-%d') Out[24]: '2011-01-03'

表11-2列出了全部的格式化编码。

表11-2 datetime格式定义（兼容ISO C89）

datetime.strptime可以用这些格式化编码将字符串转换为日期：

In [25]: value = '2011-01-03' In [26]: datetime.strptime(value, '%Y-%m-%d') Out[26]: datetime.datetime(2011, 1, 3, 0, 0) In [27]: datestrs = ['7/6/2011', '8/6/2011'] In [28]: [datetime.strptime(x, '%m/%d/%Y') for x in datestrs] Out[28]: [datetime.datetime(2011, 7, 6, 0, 0), datetime.datetime(2011, 8, 6, 0, 0)]

datetime.strptime是通过已知格式进行日期解析的最佳方式。但是每次都要编写格式定义是很麻烦的事情，尤其是对于一些常见的日期格式。这种情况下，你可以用dateutil这个第三方包中的parser.parse方法（pandas中已经自动安装好了）：

In [29]: from dateutil.parser import parse In [30]: parse('2011-01-03') Out[30]: datetime.datetime(2011, 1, 3, 0, 0)

dateutil可以解析几乎所有人类能够理解的日期表示形式：

In [31]: parse('Jan 31, 1997 10:45 PM') Out[31]: datetime.datetime(1997, 1, 31, 22, 45)

在国际通用的格式中，日出现在月的前面很普遍，传入dayfirst=True即可解决这个问题：

In [32]: parse('6/12/2011', dayfirst=True) Out[32]: datetime.datetime(2011, 12, 6, 0, 0)

pandas通常是用于处理成组日期的，不管这些日期是DataFrame的轴索引还是列。to_datetime方法可以解析多种不同的日期表示形式。对标准日期格式（如ISO8601）的解析非常快：

In [33]: datestrs = ['2011-07-06 12:00:00', '2011-08-06 00:00:00'] In [34]: pd.to_datetime(datestrs) Out[34]: DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00'], dtype='dat etime64[ns]', freq=None)

它还可以处理缺失值（None、空字符串等）：

In [35]: idx = pd.to_datetime(datestrs + [None]) In [36]: idx Out[36]: DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00', 'NaT'], dty pe='datetime64[ns]', freq=None) In [37]: idx[2] Out[37]: NaT In [38]: pd.isnull(idx) Out[38]: array([False, False,  True], dtype=bool)

NaT（Not a Time）是pandas中时间戳数据的null值。

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

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

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

11.2 时间序列基础

pandas最基本的时间序列类型就是以时间戳（通常以Python字符串或datatime对象表示）为索引的Series：

In [39]: from datetime import datetime In [40]: 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 [41]: ts = pd.Series(np.random.randn(6), index=dates) In [42]: ts Out[42]: 2011-01-02   -0.204708 2011-01-05    0.478943 2011-01-07   -0.519439 2011-01-08   -0.555730 2011-01-10    1.965781 2011-01-12    1.393406 dtype: float64

这些datetime对象实际上是被放在一个DatetimeIndex中的：

In [43]: ts.index Out[43]: 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一样，不同索引的时间序列之间的算术运算会自动按日期对齐：

In [44]: ts + ts[::2] Out[44]: 2011-01-02   -0.409415 2011-01-05         NaN 2011-01-07   -1.038877 2011-01-08         NaN 2011-01-10    3.931561 2011-01-12         NaN dtype: float64

ts[::2] 是每隔两个取一个。

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

In [45]: ts.index.dtype Out[45]: dtype('<M8[ns]')

DatetimeIndex中的各个标量值是pandas的Timestamp对象：

In [46]: stamp = ts.index[0] In [47]: stamp Out[47]: Timestamp('2011-01-02 00:00:00')

只要有需要，TimeStamp可以随时自动转换为datetime对象。此外，它还可以存储频率信息（如果有的话），且知道如何执行时区转换以及其他操作。稍后将对此进行详细讲解。

索引、选取、子集构造

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

In [48]: stamp = ts.index[2] In [49]: ts[stamp] Out[49]: -0.51943871505673811

还有一种更为方便的用法：传入一个可以被解释为日期的字符串：

In [50]: ts['1/10/2011'] Out[50]: 1.9657805725027142 In [51]: ts['20110110'] Out[51]: 1.9657805725027142

对于较长的时间序列，只需传入“年”或“年月”即可轻松选取数据的切片：

In [52]: longer_ts = pd.Series(np.random.randn(1000),   ....:                       index=pd.date_range('1/1/2000', periods=1000)) In [53]: longer_ts Out[53]: 2000-01-01    0.092908 2000-01-02    0.281746 2000-01-03    0.769023 2000-01-04    1.246435 2000-01-05    1.007189 2000-01-06   -1.296221 2000-01-07    0.274992 2000-01-08    0.228913 2000-01-09    1.352917 2000-01-10    0.886429                ...   2002-09-17   -0.139298 2002-09-18   -1.159926 2002-09-19    0.618965 2002-09-20    1.373890 2002-09-21   -0.983505 2002-09-22    0.930944 2002-09-23   -0.811676 2002-09-24   -1.830156 2002-09-25   -0.138730 2002-09-26    0.334088 Freq: D, Length: 1000, dtype: float64 In [54]: longer_ts['2001'] Out[54]: 2001-01-01    1.599534 2001-01-02    0.474071 2001-01-03    0.151326 2001-01-04   -0.542173 2001-01-05   -0.475496 2001-01-06    0.106403 2001-01-07   -1.308228 2001-01-08    2.173185 2001-01-09    0.564561 2001-01-10   -0.190481                ...   2001-12-22    0.000369 2001-12-23    0.900885 2001-12-24   -0.454869 2001-12-25   -0.864547 2001-12-26    1.129120 2001-12-27    0.057874 2001-12-28   -0.433739 2001-12-29    0.092698 2001-12-30   -1.397820 2001-12-31    1.457823 Freq: D, Length: 365, dtype: float64

这里，字符串“2001”被解释成年，并根据它选取时间区间。指定月也同样奏效：

In [55]: longer_ts['2001-05'] Out[55]: 2001-05-01   -0.622547 2001-05-02    0.936289 2001-05-03    0.750018 2001-05-04   -0.056715 2001-05-05    2.300675 2001-05-06    0.569497 2001-05-07    1.489410 2001-05-08    1.264250 2001-05-09   -0.761837 2001-05-10   -0.331617                ...   2001-05-22    0.503699 2001-05-23   -1.387874 2001-05-24    0.204851 2001-05-25    0.603705 2001-05-26    0.545680 2001-05-27    0.235477 2001-05-28    0.111835 2001-05-29   -1.251504 2001-05-30   -2.949343 2001-05-31    0.634634 Freq: D, Length: 31, dtype: float64

datetime对象也可以进行切片：

In [56]: ts[datetime(2011, 1, 7):] Out[56]: 2011-01-07   -0.519439 2011-01-08   -0.555730 2011-01-10    1.965781 2011-01-12    1.393406 dtype: float64

由于大部分时间序列数据都是按照时间先后排序的，因此你也可以用不存在于该时间序列中的时间戳对其进行切片（即范围查询）：

In [57]: ts Out[57]: 2011-01-02   -0.204708 2011-01-05    0.478943 2011-01-07   -0.519439 2011-01-08   -0.555730 2011-01-10    1.965781 2011-01-12    1.393406 dtype: float64 In [58]: ts['1/6/2011':'1/11/2011'] Out[58]: 2011-01-07   -0.519439 2011-01-08   -0.555730 2011-01-10    1.965781 dtype: float64

跟之前一样，你可以传入字符串日期、datetime或Timestamp。注意，这样切片所产生的是源时间序列的视图，跟NumPy数组的切片运算是一样的。

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

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

In [59]: ts.truncate(after='1/9/2011') Out[59]: 2011-01-02   -0.204708 2011-01-05    0.478943 2011-01-07   -0.519439 2011-01-08   -0.555730 dtype: float64

这些操作对DataFrame也有效。例如，对DataFrame的行进行索引：

In [60]: dates = pd.date_range('1/1/2000', periods=100, freq='W-WED') In [61]: long_df = pd.DataFrame(np.random.randn(100, 4),   ....:                        index=dates,   ....:                        columns=['Colorado', 'Texas',   ....:                                 'New York', 'Ohio']) In [62]: long_df.loc['5-2001'] Out[62]:            Colorado     Texas  New York      Ohio 2001-05-02 -0.006045  0.490094 -0.277186 -0.707213 2001-05-09 -0.560107  2.735527  0.927335  1.513906 2001-05-16  0.538600  1.273768  0.667876 -0.969206 2001-05-23  1.676091 -0.817649  0.050188  1.951312 2001-05-30  3.260383  0.963301  1.201206 -1.852001

带有重复索引的时间序列

在某些应用场景中，可能会存在多个观测数据落在同一个时间点上的情况。下面就是一个例子：

In [63]: dates = pd.DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000',   ....:                           '1/2/2000', '1/3/2000']) In [64]: dup_ts = pd.Series(np.arange(5), index=dates) In [65]: dup_ts Out[65]: 2000-01-01    0 2000-01-02    1 2000-01-02    2 2000-01-02    3 2000-01-03    4 dtype: int64

通过检查索引的is_unique属性，我们就可以知道它是不是唯一的：

In [66]: dup_ts.index.is_unique Out[66]: False

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

In [67]: dup_ts['1/3/2000']  # not duplicated Out[67]: 4 In [68]: dup_ts['1/2/2000']  # duplicated Out[68]: 2000-01-02    1 2000-01-02    2 2000-01-02    3 dtype: int64

假设你想要对具有非唯一时间戳的数据进行聚合。一个办法是使用groupby，并传入level=0：

In [69]: grouped = dup_ts.groupby(level=0) In [70]: grouped.mean() Out[70]: 2000-01-01    0 2000-01-02    2 2000-01-03    4 dtype: int64 In [71]: grouped.count() Out[71]: 2000-01-01    1 2000-01-02    3 2000-01-03    1 dtype: int64

赞赏作者

Python爱好者社区历史文章大合集：

福利：文末扫码立刻关注公众号，“Python爱好者社区”，开始学习Python课程：

关注后在公众号内回复“课程”即可获取：

小编的Python入门视频课程！！！

崔老师爬虫实战案例免费学习视频。

丘老师数据科学入门指导免费学习视频。

陈老师数据分析报告制作免费学习视频。

玩转大数据分析！Spark2.X+Python 精华实战课程免费学习视频。

丘老师Python网络爬虫实战免费学习视频。