• 11.5 时期及其算术运算
    • 时期的频率转换
    • 按季度计算的时期频率
    • 将Timestamp转换为Period（及其反向过程）
    • 通过数组创建PeriodIndex

    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