11.5 时期及其算术运算

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

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

    在将高频率转换为低频率时，超时期（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. 2009-12-31   -0.302988
    7. Freq: B, dtype: float64

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

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

    在以1月结束的财年中，2012Q4是从11月到1月（将其转换为日型频率就明白了）。图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

    通过使用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
    14. In [196]: ts2.to_period('M')
    15. Out[196]: 
    16. 2000-01    0.244175
    17. 2000-01    0.423331
    18. 2000-01   -0.654040
    19. 2000-02    2.089154
    20. 2000-02   -0.060220
    21. 2000-02   -0.167933
    22. 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

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

    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