时间序列基础

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

  1. In [346]: from datetime import datetime
  2.  
  3. In [347]: dates = [datetime(2011, 1, 2), datetime(2011, 1, 5), datetime(2011, 1, 7),
  4.      ...:          datetime(2011, 1, 8), datetime(2011, 1, 10), datetime(2011, 1, 12)]
  5.  
  6. In [348]: ts = Series(np.random.randn(6), index=dates)
  7.  
  8. In [349]: ts
  9. Out[349]:
  10. 2011-01-02        0.690002
  11. 2011-01-05        1.001543
  12. 2011-01-07       -0.503087
  13. 2011-01-08       -0.622274
  14. 2011-01-10       -0.921169
  15. 2011-01-12       -0.726213

这些datetime对象实际上是被放在一个DatetimeIndex中的。现在，变量ts就成为一个TimeSeries了：

  1. In [350]: type(ts)
  2. Out[350]: pandas.core.series.TimeSeries
  3.  
  4. In [351]: ts.index
  5. Out[351]:
  6. <class 'pandas.tseries.index.DatetimeIndex'>
  7. [2011-01-02 00:00:00, ..., 2011-01-12 00:00:00]
  8. Length: 6, Freq: None, Timezone: None

注意： 没必要显式使用TimeSeries的构造函数。当创建一个带有DatetimeIndex的Series时，pandas就会知道该对象是一个时间序列。

跟其他Series一样，不同索引的时间序列之间的算术运算会自动按日期对齐：

  1. In [352]: ts + ts[::2]
  2. Out[352]:
  3. 2011-01-02   1.380004
  4. 2011-01-05        NaN
  5. 2011-01-07  -1.006175
  6. 2011-01-08        NaN
  7. 2011-01-10  -1.842337
  8. 2011-01-12        NaN

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

  1. In [353]: ts.index.dtype
  2. Out[353]: dtype('datetime64[ns]')

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

  1. In [354]: stamp = ts.index[0]
  2.  
  3. In [355]: stamp
  4. Out[355]: <Timestamp: 2011-01-02 00:00:00>

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

索引、选取、子集构造

由于TimeSeries是Series的一个子类，所以在索引以及数据选取方面它们的行为是一样的：

  1. In [356]: stamp = ts.index[2]
  2.  
  3. In [357]: ts[stamp]
  4. Out[357]: -0.50308739136034464

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

  1. In [358]: ts['1/10/2011']
  2. Out[358]: -0.92116860801301081
  3. In [359]: ts['20110110']
  4. Out[359]: -0.92116860801301081

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

  1. In [360]: longer_ts = Series(np.random.randn(1000),
  2.      ...:                    index=pd.date_range('1/1/2000', periods=1000))
  3.  
  4. In [361]: longer_ts
  5. Out[361]:
  6. 2000-01-01    0.222896
  7. 2000-01-02    0.051316
  8. 2000-01-03   -1.157719
  9. 2000-01-04    0.816707
  10. ...
  11. 2002-09-23   -0.395813
  12. 2002-09-24   -0.180737
  13. 2002-09-25    1.337508
  14. 2002-09-26   -0.416584
  15. Freq: D, Length: 1000
  16.  
  17. In [362]: longer_ts['2001']
  18. Out[362]:
  19. 2001-01-01   -1.499503
  20. 2001-01-02    0.545154
  21. 2001-01-03    0.400823
  22. 2001-01-04   -1.946230
  23. ...
  24. 2001-12-28   -1.568139
  25. 2001-12-29   -0.900887
  26. 2001-12-30    0.652346
  27. 2001-12-31    0.871600
  28. Freq: D, Length: 365
  29. In [363]: longer_ts['2001-05']
  30. Out[363]:
  31. 2001-05-01    1.662014
  32. 2001-05-02   -1.189203
  33. 2001-05-03    0.093597
  34. 2001-05-04   -0.539164
  35. ...
  36. 2001-05-28   -0.683066
  37. 2001-05-29   -0.950313
  38. 2001-05-30    0.400710
  39. 2001-05-31   -0.126072
  40. Freq: D, Length: 31

通过日期进行切片的方式只对规则Series有效：

  1. In [364]: ts[datetime(2011, 1, 7):]
  2. Out[364]:
  3. 2011-01-07   -0.503087
  4. 2011-01-08   -0.622274
  5. 2011-01-10   -0.921169
  6. 2011-01-12   -0.726213

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

  1. In [365]: ts
  2. Out[365]:
  3. 2011-01-02    0.690002
  4. 2011-01-05    1.001543
  5. 2011-01-07   -0.503087
  6. 2011-01-08   -0.622274
  7. 2011-01-10   -0.921169
  8. 2011-01-12   -0.726213
  9. In [366]: ts['1/6/2011':'1/11/2011']
  10. Out[366]:
  11. 2011-01-07   -0.503087
  12. 2011-01-08   -0.622274
  13. 2011-01-10   -0.921169

跟之前一样，这里可以传入字符串日期、datetime或Timestamp。注意，这样切片所产生的是源时间序列的视图，跟NumPy数组的切片运算是一样的。此外，还有一个等价的实例方法也可以截取两个日期之间TimeSeries：

  1. In [367]: ts.truncate(after='1/9/2011')
  2. Out[367]:
  3. 2011-01-02    0.690002
  4. 2011-01-05    1.001543
  5. 2011-01-07   -0.503087
  6. 2011-01-08   -0.622274

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

  1. In [368]: dates = pd.date_range('1/1/2000', periods=100, freq='W-WED')
  2.  
  3. In [369]: long_df = DataFrame(np.random.randn(100, 4),
  4.      ...:                     index=dates,
  5.      ...:                     columns=['Colorado', 'Texas', 'New York', 'Ohio'])
  6.  
  7. In [370]: long_df.ix['5-2001']
  8. Out[370]:
  9.             Colorado     Texas  New York      Ohio
  10. 2001-05-02  0.943479 -0.349366  0.530412 -0.508724
  11. 2001-05-09  0.230643 -0.065569 -0.248717 -0.587136
  12. 2001-05-16 -1.022324  1.060661  0.954768 -0.511824
  13. 2001-05-23 -1.387680  0.767902 -1.164490  1.527070
  14. 2001-05-30  0.287542  0.715359 -0.345805  0.470886

带有重复索引的时间序列

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

  1. In [371]: dates = pd.DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000', '1/2/2000',
  2.      ...:                           '1/3/2000'])
  3.  
  4. In [372]: dup_ts = Series(np.arange(5), index=dates)
  5.  
  6. In [373]: dup_ts
  7. Out[373]:
  8. 2000-01-01    0
  9. 2000-01-02    1
  10. 2000-01-02    2
  11. 2000-01-02    3
  12. 2000-01-03    4

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

  1. In [374]: dup_ts.index.is_unique
  2. Out[374]: False

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

  1. In [375]: dup_ts['1/3/2000']  # 不重复
  2. Out[375]: 4
  3.  
  4. In [376]: dup_ts['1/2/2000']  # 重复
  5. Out[376]:
  6. 2000-01-02    1
  7. 2000-01-02    2
  8. 2000-01-02    3

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

  1. In [377]: grouped = dup_ts.groupby(level=0)
  2.  
  3. In [378]: grouped.mean()     In [379]: grouped.count()
  4. Out[378]:                    Out[379]:
  5. 2000-01-01    0              2000-01-01    1
  6. 2000-01-02    2              2000-01-02    3
  7. 2000-01-03    4              2000-01-03    1