11.5 时期及其算术运算

时期（period）表示的是时间区间，比如数日、数月、数季、数年等。Period类所表示的就是这种数据类型，其构造函数需要用到一个字符串或整数，以及表11-4中的频率：

  1. In [149]: p = pd.Period(2007, freq='A-DEC')
  3. In [150]: p
  4. Out[150]: Period('2007', 'A-DEC')

这里，这个Period对象表示的是从2007年1月1日到2007年12月31日之间的整段时间。只需对Period对象加上或减去一个整数即可达到根据其频率进行位移的效果：

  1. In [151]: p + 5
  2. Out[151]: Period('2012', 'A-DEC')
  4. In [152]: p - 2
  5. Out[152]: Period('2005', 'A-DEC')

如果两个Period对象拥有相同的频率，则它们的差就是它们之间的单位数量：

  1. In [153]: pd.Period('2014', freq='A-DEC') - p
  2. Out[153]: 7

period_range函数可用于创建规则的时期范围：

  1. In [154]: rng = pd.period_range('2000-01-01', '2000-06-30', freq='M')
  3. In [155]: rng
  4. Out[155]: PeriodIndex(['2000-01', '2000-02', '2000-03', '2000-04', '2000-05', '20
  5. 00-06'], dtype='period[M]', freq='M')

PeriodIndex类保存了一组Period，它可以在任何pandas数据结构中被用作轴索引：

  1. In [156]: pd.Series(np.random.randn(6), index=rng)
  2. Out[156]: 
  3. 2000-01   -0.514551
  4. 2000-02   -0.559782
  5. 2000-03   -0.783408
  6. 2000-04   -1.797685
  7. 2000-05   -0.172670
  8. 2000-06    0.680215
  9. Freq: M, dtype: float64

如果你有一个字符串数组，你也可以使用PeriodIndex类：

  1. In [157]: values = ['2001Q3', '2002Q2', '2003Q1']
  3. In [158]: index = pd.PeriodIndex(values, freq='Q-DEC')
  5. In [159]: index
  6. Out[159]: PeriodIndex(['2001Q3', '2002Q2', '2003Q1'], dtype='period[Q-DEC]', freq
  7. ='Q-DEC')

时期的频率转换

Period和PeriodIndex对象都可以通过其asfreq方法被转换成别的频率。假设我们有一个年度时期，希望将其转换为当年年初或年末的一个月度时期。该任务非常简单：

  1. In [160]: p = pd.Period('2007', freq='A-DEC')
  3. In [161]: p
  4. Out[161]: Period('2007', 'A-DEC')
  6. In [162]: p.asfreq('M', how='start')
  7. Out[162]: Period('2007-01', 'M')
  9. In [163]: p.asfreq('M', how='end')
  10. Out[163]: Period('2007-12', 'M')

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

  1. In [164]: p = pd.Period('2007', freq='A-JUN')
  3. In [165]: p
  4. Out[165]: Period('2007', 'A-JUN')
  6. In [166]: p.asfreq('M', 'start')
  7. Out[166]: Period('2006-07', 'M')
  9. In [167]: p.asfreq('M', 'end')
  10. Out[167]: Period('2007-06', 'M')

图11-1 Period频率转换示例

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

  1. In [168]: p = pd.Period('Aug-2007', 'M')
  3. In [169]: p.asfreq('A-JUN')
  4. Out[169]: Period('2008', 'A-JUN')

完整的PeriodIndex或TimeSeries的频率转换方式也是如此：

  1. In [170]: rng = pd.period_range('2006', '2009', freq='A-DEC')
  3. In [171]: ts = pd.Series(np.random.randn(len(rng)), index=rng)
  5. In [172]: ts
  6. Out[172]: 
  7. 2006    1.607578
  8. 2007    0.200381
  9. 2008   -0.834068
  10. 2009   -0.302988
  11. Freq: A-DEC, dtype: float64
  13. In [173]: ts.asfreq('M', how='start')
  14. Out[173]: 
  15. 2006-01    1.607578
  16. 2007-01    0.200381
  17. 2008-01   -0.834068
  18. 2009-01   -0.302988
  19. Freq: M, dtype: float64

这里，根据年度时期的第一个月，每年的时期被取代为每月的时期。如果我们想要每年的最后一个工作日，我们可以使用“B”频率，并指明想要该时期的末尾：

  1. In [174]: ts.asfreq('B', how='end')
  3. Out[174]: 
  4. 2006-12-29    1.607578
  5. 2007-12-31    0.200381
  6. 2008-12-31   -0.834068
  7. 2009-12-31   -0.302988
  8. Freq: B, dtype: float64

按季度计算的时期频率

季度型数据在会计、金融等领域中很常见。许多季度型数据都会涉及“财年末”的概念，通常是一年12个月中某月的最后一个日历日或工作日。就这一点来说，时期”2012Q4”根据财年末的不同会有不同的含义。pandas支持12种可能的季度型频率，即Q-JAN到Q-DEC：

  1. In [175]: p = pd.Period('2012Q4', freq='Q-JAN')
  3. In [176]: p
  4. Out[176]: Period('2012Q4', 'Q-JAN')

在以1月结束的财年中，2012Q4是从11月到1月（将其转换为日型频率就明白了）。图11-2对此进行了说明：

  1. In [177]: p.asfreq('D', 'start')
  2. Out[177]: Period('2011-11-01', 'D')
  4. In [178]: p.asfreq('D', 'end')
  5. Out[178]: Period('2012-01-31', 'D')

图11.2 不同季度型频率之间的转换

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

  1. In [179]: p4pm = (p.asfreq('B', 'e') - 1).asfreq('T', 's') + 16 * 60
  3. In [180]: p4pm
  4. Out[180]: Period('2012-01-30 16:00', 'T')
  6. In [181]: p4pm.to_timestamp()
  7. Out[181]: Timestamp('2012-01-30 16:00:00')

period_range可用于生成季度型范围。季度型范围的算术运算也跟上面是一样的：

  1. In [182]: rng = pd.period_range('2011Q3', '2012Q4', freq='Q-JAN')
  3. In [183]: ts = pd.Series(np.arange(len(rng)), index=rng)
  5. In [184]: ts
  6. Out[184]: 
  7. 2011Q3    0
  8. 2011Q4    1
  9. 2012Q1    2
  10. 2012Q2    3
  11. 2012Q3    4
  12. 2012Q4    5
  13. Freq: Q-JAN, dtype: int64
  15. In [185]: new_rng = (rng.asfreq('B', 'e') - 1).asfreq('T', 's') + 16 * 60
  17. In [186]: ts.index = new_rng.to_timestamp()
  19. In [187]: ts
  20. Out[187]:
  21. 2010-10-28 16:00:00    0
  22. 2011-01-28 16:00:00    1
  23. 2011-04-28 16:00:00    2
  24. 2011-07-28 16:00:00    3
  25. 2011-10-28 16:00:00    4
  26. 2012-01-30 16:00:00    5
  27. dtype: int64

将Timestamp转换为Period（及其反向过程）

通过使用to_period方法，可以将由时间戳索引的Series和DataFrame对象转换为以时期索引：

  1. In [188]: rng = pd.date_range('2000-01-01', periods=3, freq='M')
  3. In [189]: ts = pd.Series(np.random.randn(3), index=rng)
  5. In [190]: ts
  6. Out[190]: 
  7. 2000-01-31    1.663261
  8. 2000-02-29   -0.996206
  9. 2000-03-31    1.521760
  10. Freq: M, dtype: float64
  12. In [191]: pts = ts.to_period()
  14. In [192]: pts
  15. Out[192]: 
  16. 2000-01    1.663261
  17. 2000-02   -0.996206
  18. 2000-03    1.521760
  19. Freq: M, dtype: float64

由于时期指的是非重叠时间区间，因此对于给定的频率，一个时间戳只能属于一个时期。新PeriodIndex的频率默认是从时间戳推断而来的，你也可以指定任何别的频率。结果中允许存在重复时期：

  1. In [193]: rng = pd.date_range('1/29/2000', periods=6, freq='D')
  3. In [194]: ts2 = pd.Series(np.random.randn(6), index=rng)
  5. In [195]: ts2
  6. Out[195]: 
  7. 2000-01-29    0.244175
  8. 2000-01-30    0.423331
  9. 2000-01-31   -0.654040
  10. 2000-02-01    2.089154
  11. 2000-02-02   -0.060220
  12. 2000-02-03   -0.167933
  13. Freq: D, dtype: float64
  15. In [196]: ts2.to_period('M')
  16. Out[196]: 
  17. 2000-01    0.244175
  18. 2000-01    0.423331
  19. 2000-01   -0.654040
  20. 2000-02    2.089154
  21. 2000-02   -0.060220
  22. 2000-02   -0.167933
  23. Freq: M, dtype: float64

要转换回时间戳，使用to_timestamp即可：

  1. In [197]: pts = ts2.to_period()
  3. In [198]: pts
  4. Out[198]: 
  5. 2000-01-29    0.244175
  6. 2000-01-30    0.423331
  7. 2000-01-31   -0.654040
  8. 2000-02-01    2.089154
  9. 2000-02-02   -0.060220
  10. 2000-02-03   -0.167933
  11. Freq: D, dtype: float64
  13. In [199]: pts.to_timestamp(how='end')
  14. Out[199]: 
  15. 2000-01-29    0.244175
  16. 2000-01-30    0.423331
  17. 2000-01-31   -0.654040
  18. 2000-02-01    2.089154
  19. 2000-02-02   -0.060220
  20. 2000-02-03   -0.167933
  21. Freq: D, dtype: float64

通过数组创建PeriodIndex

固定频率的数据集通常会将时间信息分开存放在多个列中。例如，在下面这个宏观经济数据集中，年度和季度就分别存放在不同的列中：

  1. In [200]: data = pd.read_csv('examples/macrodata.csv')
  3. In [201]: data.head(5)
  4. Out[201]: 
  5.      year  quarter   realgdp  realcons  realinv  realgovt  realdpi    cpi  \
  6. 0  1959.0      1.0  2710.349    1707.4  286.898   470.045   1886.9  28.98   
  7. 1  1959.0      2.0  2778.801    1733.7  310.859   481.301   1919.7  29.15   
  8. 2  1959.0      3.0  2775.488    1751.8  289.226   491.260   1916.4  29.35   
  9. 3  1959.0      4.0  2785.204    1753.7  299.356   484.052   1931.3  29.37   
  10. 4  1960.0      1.0  2847.699    1770.5  331.722   462.199   1955.5  29.54   
  11.       m1  tbilrate  unemp      pop  infl  realint  
  12. 0  139.7      2.82    5.8  177.146  0.00     0.00  
  13. 1  141.7      3.08    5.1  177.830  2.34     0.74  
  14. 2  140.5      3.82    5.3  178.657  2.74     1.09  
  15. 3  140.0      4.33    5.6  179.386  0.27     4.06  
  16. 4  139.6      3.50    5.2  180.007  2.31     1.19  
  18. In [202]: data.year
  19. Out[202]: 
  20. 0      1959.0
  21. 1      1959.0
  22. 2      1959.0
  23. 3      1959.0
  24. 4      1960.0
  25. 5      1960.0
  26. 6      1960.0
  27. 7      1960.0
  28. 8      1961.0
  29. 9      1961.0
  30.         ...  
  31. 193    2007.0
  32. 194    2007.0
  33. 195    2007.0
  34. 196    2008.0
  35. 197    2008.0
  36. 198    2008.0
  37. 199    2008.0
  38. 200    2009.0
  39. 201    2009.0
  40. 202    2009.0
  41. Name: year, Length: 203, dtype: float64
  43. In [203]: data.quarter
  44. Out[203]: 
  45. 0      1.0
  46. 1      2.0
  47. 2      3.0
  48. 3      4.0
  49. 4      1.0
  50. 5      2.0
  51. 6      3.0
  52. 7      4.0
  53. 8      1.0
  54. 9      2.0
  55.       ... 
  56. 193    2.0
  57. 194    3.0
  58. 195    4.0
  59. 196    1.0
  60. 197    2.0
  61. 198    3.0
  62. 199    4.0
  63. 200    1.0
  64. 201    2.0
  65. 202    3.0
  66. Name: quarter, Length: 203, dtype: float64

通过将这些数组以及一个频率传入PeriodIndex，就可以将它们合并成DataFrame的一个索引：

  1. In [204]: index = pd.PeriodIndex(year=data.year, quarter=data.quarter,
  2.    .....:                        freq='Q-DEC')
  4. In [205]: index
  5. Out[205]: 
  6. PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2',
  7.              '1960Q3', '1960Q4', '1961Q1', '1961Q2',
  8.              ...
  9.              '2007Q2', '2007Q3', '2007Q4', '2008Q1', '2008Q2', '2008Q3',
  10.              '2008Q4', '2009Q1', '2009Q2', '2009Q3'],
  11.             dtype='period[Q-DEC]', length=203, freq='Q-DEC')
  13. In [206]: data.index = index
  15. In [207]: data.infl
  16. Out[207]: 
  17. 1959Q1    0.00
  18. 1959Q2    2.34
  19. 1959Q3    2.74
  20. 1959Q4    0.27
  21. 1960Q1    2.31
  22. 1960Q2    0.14
  23. 1960Q3    2.70
  24. 1960Q4    1.21
  25. 1961Q1   -0.40
  26. 1961Q2    1.47
  27.           ... 
  28. 2007Q2    2.75
  29. 2007Q3    3.45
  30. 2007Q4    6.38
  31. 2008Q1    2.82
  32. 2008Q2    8.53
  33. 2008Q3   -3.16
  34. 2008Q4   -8.79
  35. 2009Q1    0.94
  36. 2009Q2    3.37
  37. 2009Q3    3.56
  38. Freq: Q-DEC, Name: infl, Length: 203, dtype: float64