时间差

Timedelta，时间差，即时间之间的差异，用 日、时、分、秒 等时间单位表示，时间单位可为正，也可为负。

Timedelta 是 datetime.timedelta 的子类，两者的操作方式相似，但 Timedelta 兼容 np.timedelta64 等数据类型，还支持自定义表示形式、能解析多种类型的数据，并支持自有属性。

解析数据，生成时间差

Timedelta() 支持用多种参数生成时间差：

  1. In [1]: import datetime
  3. # 字符串
  4. In [2]: pd.Timedelta('1 days')
  5. Out[2]: Timedelta('1 days 00:00:00')
  7. In [3]: pd.Timedelta('1 days 00:00:00')
  8. Out[3]: Timedelta('1 days 00:00:00')
  10. In [4]: pd.Timedelta('1 days 2 hours')
  11. Out[4]: Timedelta('1 days 02:00:00')
  13. In [5]: pd.Timedelta('-1 days 2 min 3us')
  14. Out[5]: Timedelta('-2 days +23:57:59.999997')
  16. # datetime.timedelta
  17. # 注意：必须指定关键字参数
  18. In [6]: pd.Timedelta(days=1, seconds=1)
  19. Out[6]: Timedelta('1 days 00:00:01')
  21. # 用整数与时间单位生成时间差
  22. In [7]: pd.Timedelta(1, unit='d')
  23. Out[7]: Timedelta('1 days 00:00:00')
  25. # datetime.timedelta 与 np.timedelta64
  26. In [8]: pd.Timedelta(datetime.timedelta(days=1, seconds=1))
  27. Out[8]: Timedelta('1 days 00:00:01')
  29. In [9]: pd.Timedelta(np.timedelta64(1, 'ms'))
  30. Out[9]: Timedelta('0 days 00:00:00.001000')
  32. # 用字符串表示负数时间差
  33. # 更接近 datetime.timedelta
  34. In [10]: pd.Timedelta('-1us')
  35. Out[10]: Timedelta('-1 days +23:59:59.999999')
  37. # 时间差缺失值
  38. In [11]: pd.Timedelta('nan')
  39. Out[11]: NaT
  41. In [12]: pd.Timedelta('nat')
  42. Out[12]: NaT
  44. # ISO8601 时间格式字符串
  45. In [13]: pd.Timedelta('P0DT0H1M0S')
  46. Out[13]: Timedelta('0 days 00:01:00')
  48. In [14]: pd.Timedelta('P0DT0H0M0.000000123S')
  49. Out[14]: Timedelta('0 days 00:00:00.000000')

0.23.0 版新增：增加了用 ISO8601 时间格式生成时间差。

DateOffsets（Day、Hour、Minute、Second、Milli、Micro、Nano）也可以用来生成时间差。

  1. In [15]: pd.Timedelta(pd.offsets.Second(2))
  2. Out[15]: Timedelta('0 days 00:00:02')

标量运算生成的也是 Timedelta 标量。

  1. In [16]: pd.Timedelta(pd.offsets.Day(2)) + pd.Timedelta(pd.offsets.Second(2)) +\
  2.    ....:     pd.Timedelta('00:00:00.000123')
  3.    ....: 
  4. Out[16]: Timedelta('2 days 00:00:02.000123')

to_timedelta

pd.to_timedelta() 可以把符合时间差格式的标量、数组、列表、序列等数据转换为Timedelta。输入数据是序列，输出的就是序列，输入数据是标量，输出的就是标量，其它形式的输入数据则输出 TimedeltaIndex。

to_timedelta() 可以解析单个字符串：

  1. In [17]: pd.to_timedelta('1 days 06:05:01.00003')
  2. Out[17]: Timedelta('1 days 06:05:01.000030')
  4. In [18]: pd.to_timedelta('15.5us')
  5. Out[18]: Timedelta('0 days 00:00:00.000015')

还能解析字符串列表或数组：

  1. In [19]: pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
  2. Out[19]: TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015', NaT], dtype='timedelta64[ns]', freq=None)

unit 关键字参数指定时间差的单位：

  1. In [20]: pd.to_timedelta(np.arange(5), unit='s')
  2. Out[20]: TimedeltaIndex(['00:00:00', '00:00:01', '00:00:02', '00:00:03', '00:00:04'], dtype='timedelta64[ns]', freq=None)
  4. In [21]: pd.to_timedelta(np.arange(5), unit='d')
  5. Out[21]: TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)

时间差界限

Pandas 时间差的纳秒解析度是 64 位整数，这就决定了 Timedelta 的上下限。

  1. In [22]: pd.Timedelta.min
  2. Out[22]: Timedelta('-106752 days +00:12:43.145224')
  4. In [23]: pd.Timedelta.max
  5. Out[23]: Timedelta('106751 days 23:47:16.854775')

运算

以时间差为数据的 Series 与 DataFrame 支持各种运算，datetime64 [ns] 序列或 Timestamps 减法运算生成的是timedelta64 [ns] 序列。

  1. In [24]: s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
  3. In [25]: td = pd.Series([pd.Timedelta(days=i) for i in range(3)])
  5. In [26]: df = pd.DataFrame({'A': s, 'B': td})
  7. In [27]: df
  8. Out[27]: 
  9.            A      B
  10. 0 2012-01-01 0 days
  11. 1 2012-01-02 1 days
  12. 2 2012-01-03 2 days
  14. In [28]: df['C'] = df['A'] + df['B']
  16. In [29]: df
  17. Out[29]: 
  18.            A      B          C
  19. 0 2012-01-01 0 days 2012-01-01
  20. 1 2012-01-02 1 days 2012-01-03
  21. 2 2012-01-03 2 days 2012-01-05
  23. In [30]: df.dtypes
  24. Out[30]: 
  25. A     datetime64[ns]
  26. B    timedelta64[ns]
  27. C     datetime64[ns]
  28. dtype: object
  30. In [31]: s - s.max()
  31. Out[31]: 
  32. 0   -2 days
  33. 1   -1 days
  34. 2    0 days
  35. dtype: timedelta64[ns]
  37. In [32]: s - datetime.datetime(2011, 1, 1, 3, 5)
  38. Out[32]: 
  39. 0   364 days 20:55:00
  40. 1   365 days 20:55:00
  41. 2   366 days 20:55:00
  42. dtype: timedelta64[ns]
  44. In [33]: s + datetime.timedelta(minutes=5)
  45. Out[33]: 
  46. 0   2012-01-01 00:05:00
  47. 1   2012-01-02 00:05:00
  48. 2   2012-01-03 00:05:00
  49. dtype: datetime64[ns]
  51. In [34]: s + pd.offsets.Minute(5)
  52. Out[34]: 
  53. 0   2012-01-01 00:05:00
  54. 1   2012-01-02 00:05:00
  55. 2   2012-01-03 00:05:00
  56. dtype: datetime64[ns]
  58. In [35]: s + pd.offsets.Minute(5) + pd.offsets.Milli(5)
  59. Out[35]: 
  60. 0   2012-01-01 00:05:00.005
  61. 1   2012-01-02 00:05:00.005
  62. 2   2012-01-03 00:05:00.005
  63. dtype: datetime64[ns]

timedelta64 [ns] 序列的标量运算：

  1. In [36]: y = s - s[0]
  3. In [37]: y
  4. Out[37]: 
  5. 0   0 days
  6. 1   1 days
  7. 2   2 days
  8. dtype: timedelta64[ns]

时间差序列支持 NaT 值：

  1. In [38]: y = s - s.shift()
  3. In [39]: y
  4. Out[39]: 
  5. 0      NaT
  6. 1   1 days
  7. 2   1 days
  8. dtype: timedelta64[ns]

与 datetime 类似，np.nan 把时间差设置为 NaT：

  1. In [40]: y[1] = np.nan
  3. In [41]: y
  4. Out[41]: 
  5. 0      NaT
  6. 1      NaT
  7. 2   1 days
  8. dtype: timedelta64[ns]

运算符也可以显示为逆序（序列与单个对象的运算）：

  1. In [42]: s.max() - s
  2. Out[42]: 
  3. 0   2 days
  4. 1   1 days
  5. 2   0 days
  6. dtype: timedelta64[ns]
  8. In [43]: datetime.datetime(2011, 1, 1, 3, 5) - s
  9. Out[43]: 
  10. 0   -365 days +03:05:00
  11. 1   -366 days +03:05:00
  12. 2   -367 days +03:05:00
  13. dtype: timedelta64[ns]
  15. In [44]: datetime.timedelta(minutes=5) + s
  16. Out[44]: 
  17. 0   2012-01-01 00:05:00
  18. 1   2012-01-02 00:05:00
  19. 2   2012-01-03 00:05:00
  20. dtype: datetime64[ns]

DataFrame 支持 min、max 及 idxmin、idxmax 运算：

  1. In [45]: A = s - pd.Timestamp('20120101') - pd.Timedelta('00:05:05')
  3. In [46]: B = s - pd.Series(pd.date_range('2012-1-2', periods=3, freq='D'))
  5. In [47]: df = pd.DataFrame({'A': A, 'B': B})
  7. In [48]: df
  8. Out[48]: 
  9.                   A       B
  10. 0 -1 days +23:54:55 -1 days
  11. 1   0 days 23:54:55 -1 days
  12. 2   1 days 23:54:55 -1 days
  14. In [49]: df.min()
  15. Out[49]: 
  16. A   -1 days +23:54:55
  17. B   -1 days +00:00:00
  18. dtype: timedelta64[ns]
  20. In [50]: df.min(axis=1)
  21. Out[50]: 
  22. 0   -1 days
  23. 1   -1 days
  24. 2   -1 days
  25. dtype: timedelta64[ns]
  27. In [51]: df.idxmin()
  28. Out[51]: 
  29. A    0
  30. B    0
  31. dtype: int64
  33. In [52]: df.idxmax()
  34. Out[52]: 
  35. A    2
  36. B    0
  37. dtype: int64

Series 也支持min、max 及 idxmin、idxmax 运算。标量计算结果为 Timedelta。

  1. In [53]: df.min().max()
  2. Out[53]: Timedelta('-1 days +23:54:55')
  4. In [54]: df.min(axis=1).min()
  5. Out[54]: Timedelta('-1 days +00:00:00')
  7. In [55]: df.min().idxmax()
  8. Out[55]: 'A'
  10. In [56]: df.min(axis=1).idxmin()
  11. Out[56]: 0

时间差支持 fillna 函数，参数是 Timedelta，用于指定填充值。

  1. In [57]: y.fillna(pd.Timedelta(0))
  2. Out[57]: 
  3. 0   0 days
  4. 1   0 days
  5. 2   1 days
  6. dtype: timedelta64[ns]
  8. In [58]: y.fillna(pd.Timedelta(10, unit='s'))
  9. Out[58]: 
  10. 0   0 days 00:00:10
  11. 1   0 days 00:00:10
  12. 2   1 days 00:00:00
  13. dtype: timedelta64[ns]
  15. In [59]: y.fillna(pd.Timedelta('-1 days, 00:00:05'))
  16. Out[59]: 
  17. 0   -1 days +00:00:05
  18. 1   -1 days +00:00:05
  19. 2     1 days 00:00:00
  20. dtype: timedelta64[ns]

Timedelta 还支持取反、乘法及绝对值（Abs）运算：

  1. In [60]: td1 = pd.Timedelta('-1 days 2 hours 3 seconds')
  3. In [61]: td1
  4. Out[61]: Timedelta('-2 days +21:59:57')
  6. In [62]: -1 * td1
  7. Out[62]: Timedelta('1 days 02:00:03')
  9. In [63]: - td1
  10. Out[63]: Timedelta('1 days 02:00:03')
  12. In [64]: abs(td1)
  13. Out[64]: Timedelta('1 days 02:00:03')

归约

timedelta64 [ns] 数值归约运算返回的是 Timedelta 对象。 一般情况下，NaT 不计数。

  1. In [65]: y2 = pd.Series(pd.to_timedelta(['-1 days +00:00:05', 'nat',
  2.    ....:                                 '-1 days +00:00:05', '1 days']))
  3.    ....: 
  5. In [66]: y2
  6. Out[66]: 
  7. 0   -1 days +00:00:05
  8. 1                 NaT
  9. 2   -1 days +00:00:05
  10. 3     1 days 00:00:00
  11. dtype: timedelta64[ns]
  13. In [67]: y2.mean()
  14. Out[67]: Timedelta('-1 days +16:00:03.333333')
  16. In [68]: y2.median()
  17. Out[68]: Timedelta('-1 days +00:00:05')
  19. In [69]: y2.quantile(.1)
  20. Out[69]: Timedelta('-1 days +00:00:05')
  22. In [70]: y2.sum()
  23. Out[70]: Timedelta('-1 days +00:00:10')

频率转换

时间差除法把 Timedelta 序列、TimedeltaIndex、Timedelta 标量转换为其它“频率”，astype 也可以将之转换为指定的时间差。这些运算生成的是序列，并把 NaT 转换为 nan。 注意，NumPy 标量除法是真除法，astype 则等同于取底整除（Floor Division）。

::: tip 说明

Floor Division ，即两数的商为向下取整，如，9 / 2 = 4。又译作地板除或向下取整除，本文译作取底整除；

扩展知识：

Ceiling Division，即两数的商为向上取整，如，9 / 2 = 5。又译作屋顶除或向上取整除，本文译作取顶整除。

:::

  1. In [71]: december = pd.Series(pd.date_range('20121201', periods=4))
  3. In [72]: january = pd.Series(pd.date_range('20130101', periods=4))
  5. In [73]: td = january - december
  7. In [74]: td[2] += datetime.timedelta(minutes=5, seconds=3)
  9. In [75]: td[3] = np.nan
  11. In [76]: td
  12. Out[76]: 
  13. 0   31 days 00:00:00
  14. 1   31 days 00:00:00
  15. 2   31 days 00:05:03
  16. 3                NaT
  17. dtype: timedelta64[ns]
  19. # 转为日
  20. In [77]: td / np.timedelta64(1, 'D')
  21. Out[77]: 
  22. 0    31.000000
  23. 1    31.000000
  24. 2    31.003507
  25. 3          NaN
  26. dtype: float64
  28. In [78]: td.astype('timedelta64[D]')
  29. Out[78]: 
  30. 0    31.0
  31. 1    31.0
  32. 2    31.0
  33. 3     NaN
  34. dtype: float64
  36. # 转为秒
  37. In [79]: td / np.timedelta64(1, 's')
  38. Out[79]: 
  39. 0    2678400.0
  40. 1    2678400.0
  41. 2    2678703.0
  42. 3          NaN
  43. dtype: float64
  45. In [80]: td.astype('timedelta64[s]')
  46. Out[80]: 
  47. 0    2678400.0
  48. 1    2678400.0
  49. 2    2678703.0
  50. 3          NaN
  51. dtype: float64
  53. # 转为月 （此处用常量表示）
  54. In [81]: td / np.timedelta64(1, 'M')
  55. Out[81]: 
  56. 0    1.018501
  57. 1    1.018501
  58. 2    1.018617
  59. 3         NaN
  60. dtype: float64

timedelta64 [ns] 序列与整数或整数序列相乘或相除，生成的也是 timedelta64 [ns] 序列。

  1. In [82]: td * -1
  2. Out[82]: 
  3. 0   -31 days +00:00:00
  4. 1   -31 days +00:00:00
  5. 2   -32 days +23:54:57
  6. 3                  NaT
  7. dtype: timedelta64[ns]
  9. In [83]: td * pd.Series([1, 2, 3, 4])
  10. Out[83]: 
  11. 0   31 days 00:00:00
  12. 1   62 days 00:00:00
  13. 2   93 days 00:15:09
  14. 3                NaT
  15. dtype: timedelta64[ns]

timedelta64 [ns] 序列与 Timedelta 标量相除的结果为取底整除的整数序列。

  1. In [84]: td // pd.Timedelta(days=3, hours=4)
  2. Out[84]: 
  3. 0    9.0
  4. 1    9.0
  5. 2    9.0
  6. 3    NaN
  7. dtype: float64
  9. In [85]: pd.Timedelta(days=3, hours=4) // td
  10. Out[85]: 
  11. 0    0.0
  12. 1    0.0
  13. 2    0.0
  14. 3    NaN
  15. dtype: float64

Timedelta 的求余（mod(%)）与除余（divmod）运算，支持时间差与数值参数。

  1. In [86]: pd.Timedelta(hours=37) % datetime.timedelta(hours=2)
  2. Out[86]: Timedelta('0 days 01:00:00')
  4. # 除余运算的参数为时间差时，返回一对值（int, Timedelta）
  5. In [87]: divmod(datetime.timedelta(hours=2), pd.Timedelta(minutes=11))
  6. Out[87]: (10, Timedelta('0 days 00:10:00'))
  8. # 除余运算的参数为数值时，也返回一对值（Timedelta, Timedelta）
  9. In [88]: divmod(pd.Timedelta(hours=25), 86400000000000)
  10. Out[88]: (Timedelta('0 days 00:00:00.000000'), Timedelta('0 days 01:00:00'))

属性

Timedelta 或 TimedeltaIndex 的组件可以直接访问 days、seconds、microseconds、nanoseconds 等属性。这些属性与datetime.timedelta 的返回值相同，例如，.seconds 属性表示大于等于 0 天且小于 1 天的秒数。带符号的 Timedelta 返回的值也带符号。

Series 的 .dt 属性也可以直接访问这些数据。

::: tip 注意

这些属性不是 Timedelta 显示的值。.components 可以提取显示的值。

:::

对于 Series：

  1. In [89]: td.dt.days
  2. Out[89]: 
  3. 0    31.0
  4. 1    31.0
  5. 2    31.0
  6. 3     NaN
  7. dtype: float64
  9. In [90]: td.dt.seconds
  10. Out[90]: 
  11. 0      0.0
  12. 1      0.0
  13. 2    303.0
  14. 3      NaN
  15. dtype: float64

直接访问 Timedelta 标量字段值。

  1. In [91]: tds = pd.Timedelta('31 days 5 min 3 sec')
  3. In [92]: tds.days
  4. Out[92]: 31
  6. In [93]: tds.seconds
  7. Out[93]: 303
  9. In [94]: (-tds).seconds
  10. Out[94]: 86097

.components 属性可以快速访问时间差的组件，返回结果是 DataFrame。 下列代码输出 Timedelta 的显示值。

  1. In [95]: td.dt.components
  2. Out[95]: 
  3.    days  hours  minutes  seconds  milliseconds  microseconds  nanoseconds
  4. 0  31.0    0.0      0.0      0.0           0.0           0.0          0.0
  5. 1  31.0    0.0      0.0      0.0           0.0           0.0          0.0
  6. 2  31.0    0.0      5.0      3.0           0.0           0.0          0.0
  7. 3   NaN    NaN      NaN      NaN           NaN           NaN          NaN
  9. In [96]: td.dt.components.seconds
  10. Out[96]: 
  11. 0    0.0
  12. 1    0.0
  13. 2    3.0
  14. 3    NaN
  15. Name: seconds, dtype: float64

.isoformat 方法可以把 Timedelta 转换为 ISO8601 时间格式字符串。

0.20.0 版新增。

  1. In [97]: pd.Timedelta(days=6, minutes=50, seconds=3,
  2.    ....:              milliseconds=10, microseconds=10,
  3.    ....:              nanoseconds=12).isoformat()
  4.    ....: 
  5. Out[97]: 'P6DT0H50M3.010010012S'

TimedeltaIndex

TimedeltaIndex 或 timedelta_range() 可以生成时间差索引。

TimedeltaIndex 支持字符串型的 Timedelta、timedelta 或 np.timedelta64对象。

np.nan、pd.NaT、nat 代表缺失值。

  1. In [98]: pd.TimedeltaIndex(['1 days', '1 days, 00:00:05', np.timedelta64(2, 'D'),
  2.    ....:                    datetime.timedelta(days=2, seconds=2)])
  3.    ....: 
  4. Out[98]: 
  5. TimedeltaIndex(['1 days 00:00:00', '1 days 00:00:05', '2 days 00:00:00',
  6.                 '2 days 00:00:02'],
  7.                dtype='timedelta64[ns]', freq=None)

freq 关键字参数为 infer 时，TimedeltaIndex 可以自行推断时间频率：

  1. In [99]: pd.TimedeltaIndex(['0 days', '10 days', '20 days'], freq='infer')
  2. Out[99]: TimedeltaIndex(['0 days', '10 days', '20 days'], dtype='timedelta64[ns]', freq='10D')

生成时间差范围

与 date_range() 相似，timedelta_range() 可以生成定频 TimedeltaIndex，timedelta_range 的默认频率是日历日：

  1. In [100]: pd.timedelta_range(start='1 days', periods=5)
  2. Out[100]: TimedeltaIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], dtype='timedelta64[ns]', freq='D')

timedelta_range 支持 start、end、periods 三个参数：

  1. In [101]: pd.timedelta_range(start='1 days', end='5 days')
  2. Out[101]: TimedeltaIndex(['1 days', '2 days', '3 days', '4 days', '5 days'], dtype='timedelta64[ns]', freq='D')
  4. In [102]: pd.timedelta_range(end='10 days', periods=4)
  5. Out[102]: TimedeltaIndex(['7 days', '8 days', '9 days', '10 days'], dtype='timedelta64[ns]', freq='D')

freq 参数支持各种频率别名：

  1. In [103]: pd.timedelta_range(start='1 days', end='2 days', freq='30T')
  2. Out[103]: 
  3. TimedeltaIndex(['1 days 00:00:00', '1 days 00:30:00', '1 days 01:00:00',
  4.                 '1 days 01:30:00', '1 days 02:00:00', '1 days 02:30:00',
  5.                 '1 days 03:00:00', '1 days 03:30:00', '1 days 04:00:00',
  6.                 '1 days 04:30:00', '1 days 05:00:00', '1 days 05:30:00',
  7.                 '1 days 06:00:00', '1 days 06:30:00', '1 days 07:00:00',
  8.                 '1 days 07:30:00', '1 days 08:00:00', '1 days 08:30:00',
  9.                 '1 days 09:00:00', '1 days 09:30:00', '1 days 10:00:00',
  10.                 '1 days 10:30:00', '1 days 11:00:00', '1 days 11:30:00',
  11.                 '1 days 12:00:00', '1 days 12:30:00', '1 days 13:00:00',
  12.                 '1 days 13:30:00', '1 days 14:00:00', '1 days 14:30:00',
  13.                 '1 days 15:00:00', '1 days 15:30:00', '1 days 16:00:00',
  14.                 '1 days 16:30:00', '1 days 17:00:00', '1 days 17:30:00',
  15.                 '1 days 18:00:00', '1 days 18:30:00', '1 days 19:00:00',
  16.                 '1 days 19:30:00', '1 days 20:00:00', '1 days 20:30:00',
  17.                 '1 days 21:00:00', '1 days 21:30:00', '1 days 22:00:00',
  18.                 '1 days 22:30:00', '1 days 23:00:00', '1 days 23:30:00',
  19.                 '2 days 00:00:00'],
  20.                dtype='timedelta64[ns]', freq='30T')
  22. In [104]: pd.timedelta_range(start='1 days', periods=5, freq='2D5H')
  23. Out[104]: 
  24. TimedeltaIndex(['1 days 00:00:00', '3 days 05:00:00', '5 days 10:00:00',
  25.                 '7 days 15:00:00', '9 days 20:00:00'],
  26.                dtype='timedelta64[ns]', freq='53H')

0.23.0 版新增。

用 start、end、period 可以生成等宽时间差范围，其中，start 与 end（含）是起止两端的时间，periods 为 TimedeltaIndex 里的元素数量：

  1. In [105]: pd.timedelta_range('0 days', '4 days', periods=5)
  2. Out[105]: TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)
  4. In [106]: pd.timedelta_range('0 days', '4 days', periods=10)
  5. Out[106]: 
  6. TimedeltaIndex(['0 days 00:00:00', '0 days 10:40:00', '0 days 21:20:00',
  7.                 '1 days 08:00:00', '1 days 18:40:00', '2 days 05:20:00',
  8.                 '2 days 16:00:00', '3 days 02:40:00', '3 days 13:20:00',
  9.                 '4 days 00:00:00'],
  10.                dtype='timedelta64[ns]', freq=None)

TimedeltaIndex 应用

与 DatetimeIndex、PeriodIndex 等 datetime 型索引类似，TimedeltaIndex 也可当作 pandas 对象的索引。

  1. In [107]: s = pd.Series(np.arange(100),
  2.    .....:               index=pd.timedelta_range('1 days', periods=100, freq='h'))
  3.    .....: 
  5. In [108]: s
  6. Out[108]: 
  7. 1 days 00:00:00     0
  8. 1 days 01:00:00     1
  9. 1 days 02:00:00     2
  10. 1 days 03:00:00     3
  11. 1 days 04:00:00     4
  12.                    ..
  13. 4 days 23:00:00    95
  14. 5 days 00:00:00    96
  15. 5 days 01:00:00    97
  16. 5 days 02:00:00    98
  17. 5 days 03:00:00    99
  18. Freq: H, Length: 100, dtype: int64

选择操作也差不多，可以强制转换字符串与切片：

  1. In [109]: s['1 day':'2 day']
  2. Out[109]: 
  3. 1 days 00:00:00     0
  4. 1 days 01:00:00     1
  5. 1 days 02:00:00     2
  6. 1 days 03:00:00     3
  7. 1 days 04:00:00     4
  8.                    ..
  9. 2 days 19:00:00    43
  10. 2 days 20:00:00    44
  11. 2 days 21:00:00    45
  12. 2 days 22:00:00    46
  13. 2 days 23:00:00    47
  14. Freq: H, Length: 48, dtype: int64
  16. In [110]: s['1 day 01:00:00']
  17. Out[110]: 1
  19. In [111]: s[pd.Timedelta('1 day 1h')]
  20. Out[111]: 1

TimedeltaIndex 还支持局部字符串选择，并且可以推断选择范围：

  1. In [112]: s['1 day':'1 day 5 hours']
  2. Out[112]: 
  3. 1 days 00:00:00    0
  4. 1 days 01:00:00    1
  5. 1 days 02:00:00    2
  6. 1 days 03:00:00    3
  7. 1 days 04:00:00    4
  8. 1 days 05:00:00    5
  9. Freq: H, dtype: int64

TimedeltaIndex 运算

TimedeltaIndex 与 DatetimeIndex 运算可以保留 NaT 值：

  1. In [113]: tdi = pd.TimedeltaIndex(['1 days', pd.NaT, '2 days'])
  3. In [114]: tdi.to_list()
  4. Out[114]: [Timedelta('1 days 00:00:00'), NaT, Timedelta('2 days 00:00:00')]
  6. In [115]: dti = pd.date_range('20130101', periods=3)
  8. In [116]: dti.to_list()
  9. Out[116]: 
  10. [Timestamp('2013-01-01 00:00:00', freq='D'),
  11.  Timestamp('2013-01-02 00:00:00', freq='D'),
  12.  Timestamp('2013-01-03 00:00:00', freq='D')]
  14. In [117]: (dti + tdi).to_list()
  15. Out[117]: [Timestamp('2013-01-02 00:00:00'), NaT, Timestamp('2013-01-05 00:00:00')]
  17. In [118]: (dti - tdi).to_list()
  18. Out[118]: [Timestamp('2012-12-31 00:00:00'), NaT, Timestamp('2013-01-01 00:00:00')]

转换

与 Series 频率转换类似，可以把 TimedeltaIndex 转换为其它索引。

  1. In [119]: tdi / np.timedelta64(1, 's')
  2. Out[119]: Float64Index([86400.0, nan, 172800.0], dtype='float64')
  4. In [120]: tdi.astype('timedelta64[s]')
  5. Out[120]: Float64Index([86400.0, nan, 172800.0], dtype='float64')

与标量操作类似，会返回不同类型的索引。

  1. # 时间差与日期相加，结果为日期型索引（DatetimeIndex）
  2. In [121]: tdi + pd.Timestamp('20130101')
  3. Out[121]: DatetimeIndex(['2013-01-02', 'NaT', '2013-01-03'], dtype='datetime64[ns]', freq=None)
  5. # 日期与时间戳相减，结果为日期型数据（Timestamp）
  6. # note that trying to subtract a date from a Timedelta will raise an exception
  7. In [122]: (pd.Timestamp('20130101') - tdi).to_list()
  8. Out[122]: [Timestamp('2012-12-31 00:00:00'), NaT, Timestamp('2012-12-30 00:00:00')]
  10. # 时间差与时间差相加，结果还是时间差索引
  11. In [123]: tdi + pd.Timedelta('10 days')
  12. Out[123]: TimedeltaIndex(['11 days', NaT, '12 days'], dtype='timedelta64[ns]', freq=None)
  14. # 除数是整数，则结果为时间差索引
  15. In [124]: tdi / 2
  16. Out[124]: TimedeltaIndex(['0 days 12:00:00', NaT, '1 days 00:00:00'], dtype='timedelta64[ns]', freq=None)
  18. # 除数是时间差，则结果为 Float64Index
  19. In [125]: tdi / tdi[0]
  20. Out[125]: Float64Index([1.0, nan, 2.0], dtype='float64')

重采样

与时间序列重采样一样，TimedeltaIndex 也支持重采样。

  1. In [126]: s.resample('D').mean()
  2. Out[126]: 
  3. 1 days    11.5
  4. 2 days    35.5
  5. 3 days    59.5
  6. 4 days    83.5
  7. 5 days    97.5
  8. Freq: D, dtype: float64