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
  11. In [73]: resampler = ts.resample('D')

字符串“D”是每天的意思。

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

生成日期范围

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

  1. In [74]: index = pd.date_range('2012-04-01', '2012-06-01')
  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')

默认情况下，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')
  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')

起始和结束日期定义了日期索引的严格边界。例如，如果你想要生成一个由每月最后一个工作日组成的日期索引，可以传入”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')

表11-4 基本的时间序列频率（不完整）

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

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

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

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

有时，虽然起始和结束日期带有时间信息，但你希望产生一组被规范化（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')

频率和日期偏移量

pandas中的频率是由一个基础频率（base frequency）和一个乘数组成的。基础频率通常以一个字符串别名表示，比如”M”表示每月，”H”表示每小时。对于每个基础频率，都有一个被称为日期偏移量（date offset）的对象与之对应。例如，按小时计算的频率可以用Hour类表示：

  1. In [81]: from pandas.tseries.offsets import Hour, Minute
  3. In [82]: hour = Hour()
  5. In [83]: hour
  6. Out[83]: <Hour>

传入一个整数即可定义偏移量的倍数：

  1. In [84]: four_hours = Hour(4)
  3. In [85]: four_hours
  4. Out[85]: <4 * Hours>

一般来说，无需明确创建这样的对象，只需使用诸如”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')

大部分偏移量对象都可通过加法进行连接：

  1. In [87]: Hour(2) + Minute(30)
  2. Out[87]: <150 * Minutes>

同理，你也可以传入频率字符串（如”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')

有些频率所描述的时间点并不是均匀分隔的。例如，”M”（日历月末）和”BM”（每月最后一个工作日）就取决于每月的天数，对于后者，还要考虑月末是不是周末。由于没有更好的术语，我将这些称为锚点偏移量（anchored offset）。

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

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

表11-4 时间序列的基础频率

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

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

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

WOM日期

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

  1. In [89]: rng = pd.date_range('2012-01-01', '2012-09-01', freq='WOM-3FRI')
  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')]

移动（超前和滞后）数据

移动（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'))
  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
  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
  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

当我们这样进行移动时，就会在时间序列的前面或后面产生缺失数据。

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

  1. ts / ts.shift(1) - 1

由于单纯的移位操作不会修改索引，所以部分数据会被丢弃。因此，如果频率已知，则可以将其传给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

这里还可以使用其他频率，于是你就能非常灵活地对数据进行超前和滞后处理了：

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

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

pandas的日期偏移量还可以用在datetime或Timestamp对象上：

  1. In [98]: from pandas.tseries.offsets import Day, MonthEnd
  3. In [99]: now = datetime(2011, 11, 17)
  5. In [100]: now + 3 * Day()
  6. Out[100]: Timestamp('2011-11-20 00:00:00')

如果加的是锚点偏移量（比如MonthEnd），第一次增量会将原日期向前滚动到符合频率规则的下一个日期：

  1. In [101]: now + MonthEnd()
  2. Out[101]: Timestamp('2011-11-30 00:00:00')
  4. In [102]: now + MonthEnd(2)
  5. Out[102]: Timestamp('2011-12-31 00:00:00')

通过锚点偏移量的rollforward和rollback方法，可明确地将日期向前或向后“滚动”：

  1. In [103]: offset = MonthEnd()
  3. In [104]: offset.rollforward(now)
  4. Out[104]: Timestamp('2011-11-30 00:00:00')
  6. In [105]: offset.rollback(now)
  7. Out[105]: Timestamp('2011-10-31 00:00:00')

日期偏移量还有一个巧妙的用法，即结合groupby使用这两个“滚动”方法：

  1. In [106]: ts = pd.Series(np.random.randn(20),
  2.    .....:                index=pd.date_range('1/15/2000', periods=20, freq='4d'))
  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
  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

当然，更简单、更快速地实现该功能的办法是使用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