Pandas 时间序列数据处理
介绍
Pandas 是非常著名的开源数据处理库，我们可以通过它完成对数据集进行快速读取、转换、过滤、分析等一系列操作。同样，Pandas 已经被证明为是非常强大的用于处理时间序列数据的工具。本节将介绍所有 Pandas 在时间序列数据上的处理方法。
知识点
- 创建时间对象
- 时间索引对象
- 时间算术方法
创建时间对象
在 Pandas 中关于时间序列的常见对象有 6 种，分别是 Timestamp（时间戳）、DatetimeIndex（时间戳索引）、Period（时间段）、PeriodIndex（时间段索引）、以时间为元素的 Series 和以及以时间索引的 DataFrame。本小节学习如何创建以上对象。
创建时间戳
Timestamp 时间戳表示时间轴上的某一点，以下不同代码都可以生成相同时间戳。
创建时间为 2018 年 10 月 1 日的时间戳。
In [1]:
import pandas as pd
pd.Timestamp(2018, 10, 1)
Out[1]:
Timestamp('2018-10-01 00:00:00')
也可以使创建的时间精确到时分秒。
In [2]:
pd.Timestamp("2018-10-1 10:00:1")
Out[2]:
Timestamp('2018-10-01 10:00:01')
In [3]:
from datetime import datetime
pd.Timestamp(datetime(2018, 10, 1))
Out[3]:
Timestamp('2018-10-01 00:00:00')
创建时间段
Period 时间段表示时间轴上的某一区间，以下代码都可以生成相同时间段。
In [4]:
pd.Period('2018-10')
Out[4]:
Period('2018-10', 'M')
Period() 函数后面通常有两个参数，第二个 freq 参数决定时间段的分割长度。
创建频率为日的时间段。
In [5]:
pd.Period('2018-10', freq='Y')
Out[5]:
Period('2018', 'A-DEC')
In [6]:
pd.Period('2018-10', freq='D')
Out[6]:
Period('2018-10-01', 'D')
创建时间元素的 Series
Pandas 中常用 to_datetime() 函数可以创建以时间为元素的 Series。
创建一个 Series，以三个时间的字符串作为元素。
In [7]:
df = ['2018-08-01', '2018-09-01', '2018-10-01']
pd.to_datetime(df)
Out[7]:
DatetimeIndex(['2018-08-01', '2018-09-01', '2018-10-01'], dtype='datetime64[ns]', freq=None)
可以使用多种方法创建时间元素的 Series。
In [8]:
df = pd.Series(['Sep 30, 2018', '2018-10-1', None])
pd.to_datetime(df)
Out[8]:
0 2018-09-30
1 2018-10-01
2 NaT
dtype: datetime64[ns]
In [9]:
df = pd.DataFrame({'year': [2017, 2018],
'month': [9, 10],
'day': [30, 1],
'hour': [23, 0]})
pd.to_datetime(df)
Out[9]:
0 2017-09-30 23:00:00
1 2018-10-01 00:00:00
dtype: datetime64[ns]
创建时间索引
要生成带有时间戳的索引，可以使用 DatetimeIndex() 构造函数，并传入列表或 Series 对象：
In [10]:
dates = ['2018-08-01', '2018-09-01', '2018-10-01']
index = pd.DatetimeIndex(dates)
index
Out[10]:
DatetimeIndex(['2018-08-01', '2018-09-01', '2018-10-01'], dtype='datetime64[ns]', freq=None)
实际运用中我们经常需要大量的的时间戳的索引。可以使用 date_range() 和 bdate_range() 来批量创建相同时间间隔的时间戳索引。
创建以 2018 年 9 月 30 日为开始的 250 条时间索引，相邻索引间隔时间长度为一个月。
In [11]:
index = pd.date_range('2018-9-30', periods=250, freq='M')
index
Out[11]:
DatetimeIndex(['2018-09-30', '2018-10-31', '2018-11-30', '2018-12-31',
'2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30',
'2019-05-31', '2019-06-30',
...
'2038-09-30', '2038-10-31', '2038-11-30', '2038-12-31',
'2039-01-31', '2039-02-28', '2039-03-31', '2039-04-30',
'2039-05-31', '2039-06-30'],
dtype='datetime64[ns]', length=250, freq='M')
创建以 2018 年 10 月 1 日为开始的 111 条时间索引，相邻索引间隔时间长度为一个工作日。
In [12]:
index = pd.bdate_range('2018-10-1', periods=111)
index
Out[12]:
DatetimeIndex(['2018-10-01', '2018-10-02', '2018-10-03', '2018-10-04',
'2018-10-05', '2018-10-08', '2018-10-09', '2018-10-10',
'2018-10-11', '2018-10-12',
...
'2019-02-19', '2019-02-20', '2019-02-21', '2019-02-22',
'2019-02-25', '2019-02-26', '2019-02-27', '2019-02-28',
'2019-03-01', '2019-03-04'],
dtype='datetime64[ns]', length=111, freq='B')
在 date_range() 和 bdate_range() 中可以巧妙使用 start，end， periods，freq 等参数的各种组合轻松批量创建时间索引。
在 2017 年 10 月 1 日到 2018 年 10 月 1 日间，每隔一周创建一条索引。
In [13]:
start = datetime(2017, 10, 1)
end = datetime(2018, 10, 1)
rng = pd.date_range(start, end, freq='W')
rng
Out[13]:
DatetimeIndex(['2017-10-01', '2017-10-08', '2017-10-15', '2017-10-22',
'2017-10-29', '2017-11-05', '2017-11-12', '2017-11-19',
'2017-11-26', '2017-12-03', '2017-12-10', '2017-12-17',
'2017-12-24', '2017-12-31', '2018-01-07', '2018-01-14',
'2018-01-21', '2018-01-28', '2018-02-04', '2018-02-11',
'2018-02-18', '2018-02-25', '2018-03-04', '2018-03-11',
'2018-03-18', '2018-03-25', '2018-04-01', '2018-04-08',
'2018-04-15', '2018-04-22', '2018-04-29', '2018-05-06',
'2018-05-13', '2018-05-20', '2018-05-27', '2018-06-03',
'2018-06-10', '2018-06-17', '2018-06-24', '2018-07-01',
'2018-07-08', '2018-07-15', '2018-07-22', '2018-07-29',
'2018-08-05', '2018-08-12', '2018-08-19', '2018-08-26',
'2018-09-02', '2018-09-09', '2018-09-16', '2018-09-23',
'2018-09-30'],
dtype='datetime64[ns]', freq='W-SUN')
从 2018 年 10 月 1 日向前每隔一个工作日创建一条索引，共 250 条。
In [14]:
pd.bdate_range(end=end, periods=250)
Out[14]:
DatetimeIndex(['2017-10-17', '2017-10-18', '2017-10-19', '2017-10-20',
'2017-10-23', '2017-10-24', '2017-10-25', '2017-10-26',
'2017-10-27', '2017-10-30',
...
'2018-09-18', '2018-09-19', '2018-09-20', '2018-09-21',
'2018-09-24', '2018-09-25', '2018-09-26', '2018-09-27',
'2018-09-28', '2018-10-01'],
dtype='datetime64[ns]', length=250, freq='B')
同理，时间段也能作为索引使用，需要用到 period_range()。
从 2018 年 9 月 30 日向后创建 666 条索引，相邻索引间隔时间长度为一天。
In [15]:
pi = pd.period_range('2018-9-30', periods=666)
pi
Out[15]:
PeriodIndex(['2018-09-30', '2018-10-01', '2018-10-02', '2018-10-03',
'2018-10-04', '2018-10-05', '2018-10-06', '2018-10-07',
'2018-10-08', '2018-10-09',
...
'2020-07-17', '2020-07-18', '2020-07-19', '2020-07-20',
'2020-07-21', '2020-07-22', '2020-07-23', '2020-07-24',
'2020-07-25', '2020-07-26'],
dtype='period[D]', length=666, freq='D')
创建以时间为索引的 Series 对象
以时间为索引的 Series 对象指的是在该 Series 中，元素的索引不再是 1、2、3、4、5……这样的序号，而是有序的日期和时间。
In [16]:
import numpy as np
dates = [pd.Timestamp('2018-08-01'), pd.Timestamp('2018-09-01'),
pd.Timestamp('2018-10-01')] # 创建三个时间元素。
ts = pd.Series(np.random.randn(3), dates) # 创建索引值为随机数的 Series 对象。
ts
Out[16]:
2018-08-01 0.869426
2018-09-01 1.998180
2018-10-01 0.386960
dtype: float64
同样，时间段也能作为索引。
In [18]:
periods = [pd.Period('2018-08'), pd.Period('2018-09'), pd.Period('2018-10')]
ts = pd.Series(np.random.randn(3), periods)
ts
Out[18]:
2018-08 -0.469977
2018-09 0.076098
2018-10 0.119560
Freq: M, dtype: float64
我们可以批量创建索引后再创建以时间为索引的 Series 对象。创建索引值为随机数的 Series 对象，长度与 rng 长度相同。
In [19]:
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
Out[19]:
2017-10-01 0.493787
2017-10-08 -0.688910
2017-10-15 0.448156
2017-10-22 -1.042401
2017-10-29 -0.157431
2017-11-05 0.946544
2017-11-12 -0.009933
2017-11-19 1.809738
2017-11-26 0.780451
2017-12-03 -0.671147
2017-12-10 -1.085384
2017-12-17 -0.396987
2017-12-24 0.516356
2017-12-31 -1.339113
2018-01-07 0.091994
2018-01-14 0.466957
2018-01-21 0.404413
2018-01-28 0.424614
2018-02-04 -1.523700
2018-02-11 -0.112411
2018-02-18 -0.742847
2018-02-25 -2.820375
2018-03-04 -1.026152
2018-03-11 0.249747
2018-03-18 -0.948177
2018-03-25 0.484366
2018-04-01 0.290852
2018-04-08 0.398359
2018-04-15 -0.632353
2018-04-22 -0.731030
2018-04-29 -0.443699
2018-05-06 1.394748
2018-05-13 -0.480585
2018-05-20 -0.432828
2018-05-27 0.214926
2018-06-03 1.062762
2018-06-10 -0.989706
2018-06-17 -0.014890
2018-06-24 -0.060750
2018-07-01 0.255050
2018-07-08 0.602239
2018-07-15 0.784231
2018-07-22 0.498010
2018-07-29 -0.075643
2018-08-05 -2.080412
2018-08-12 -1.452536
2018-08-19 0.757943
2018-08-26 0.459837
2018-09-02 0.654742
2018-09-09 0.924585
2018-09-16 -1.751716
2018-09-23 1.972103
2018-09-30 0.651826
Freq: W-SUN, dtype: float64
时间段也能作为索引创建 DataFrame 对象。在 2017 年第一季度和 2018 年第四季度之间每隔一个季度创建一条索引。
In [20]:
prng = pd.period_range('2017Q1', '2018Q4', freq='Q-NOV')
# 行索引为时间段索引，列索引为 A。
ps = pd.DataFrame(np.random.rand(len(prng)), columns=[
'A'], index=prng)
ps
Out[20]:
| A | |
|---|---|
| 2017Q1 | 0.342835 |
| 2017Q2 | 0.774213 |
| 2017Q3 | 0.695786 |
| 2017Q4 | 0.032892 |
| 2018Q1 | 0.239562 |
| 2018Q2 | 0.116051 |
| 2018Q3 | 0.900067 |
| 2018Q4 | 0.270152 |
时间索引对象处理
以时间戳为索引的 Series、DataFrame 对象具有与普通列表近乎相同的操作，且更具智能化。
查找
简单查找。
In [21]:
ts
Out[21]:
2017-10-01 0.493787
2017-10-08 -0.688910
2017-10-15 0.448156
2017-10-22 -1.042401
2017-10-29 -0.157431
2017-11-05 0.946544
2017-11-12 -0.009933
2017-11-19 1.809738
2017-11-26 0.780451
2017-12-03 -0.671147
2017-12-10 -1.085384
2017-12-17 -0.396987
2017-12-24 0.516356
2017-12-31 -1.339113
2018-01-07 0.091994
2018-01-14 0.466957
2018-01-21 0.404413
2018-01-28 0.424614
2018-02-04 -1.523700
2018-02-11 -0.112411
2018-02-18 -0.742847
2018-02-25 -2.820375
2018-03-04 -1.026152
2018-03-11 0.249747
2018-03-18 -0.948177
2018-03-25 0.484366
2018-04-01 0.290852
2018-04-08 0.398359
2018-04-15 -0.632353
2018-04-22 -0.731030
2018-04-29 -0.443699
2018-05-06 1.394748
2018-05-13 -0.480585
2018-05-20 -0.432828
2018-05-27 0.214926
2018-06-03 1.062762
2018-06-10 -0.989706
2018-06-17 -0.014890
2018-06-24 -0.060750
2018-07-01 0.255050
2018-07-08 0.602239
2018-07-15 0.784231
2018-07-22 0.498010
2018-07-29 -0.075643
2018-08-05 -2.080412
2018-08-12 -1.452536
2018-08-19 0.757943
2018-08-26 0.459837
2018-09-02 0.654742
2018-09-09 0.924585
2018-09-16 -1.751716
2018-09-23 1.972103
2018-09-30 0.651826
Freq: W-SUN, dtype: float64
查找前 10 条索引记录。
In [22]:
ts[:10]
Out[22]:
2017-10-01 0.493787
2017-10-08 -0.688910
2017-10-15 0.448156
2017-10-22 -1.042401
2017-10-29 -0.157431
2017-11-05 0.946544
2017-11-12 -0.009933
2017-11-19 1.809738
2017-11-26 0.780451
2017-12-03 -0.671147
Freq: W-SUN, dtype: float64
每隔 1 条记录查找 1 条索引记录。
In [23]:
ts[::2]
Out[23]:
2017-10-01 0.493787
2017-10-15 0.448156
2017-10-29 -0.157431
2017-11-12 -0.009933
2017-11-26 0.780451
2017-12-10 -1.085384
2017-12-24 0.516356
2018-01-07 0.091994
2018-01-21 0.404413
2018-02-04 -1.523700
2018-02-18 -0.742847
2018-03-04 -1.026152
2018-03-18 -0.948177
2018-04-01 0.290852
2018-04-15 -0.632353
2018-04-29 -0.443699
2018-05-13 -0.480585
2018-05-27 0.214926
2018-06-10 -0.989706
2018-06-24 -0.060750
2018-07-08 0.602239
2018-07-22 0.498010
2018-08-05 -2.080412
2018-08-19 0.757943
2018-09-02 0.654742
2018-09-16 -1.751716
2018-09-30 0.651826
Freq: 2W-SUN, dtype: float64
查找第 0、2、6 条索引记录。
In [24]:
ts[[0, 2, 6]]
Out[24]:
2017-10-01 0.493787
2017-10-15 0.448156
2017-11-12 -0.009933
dtype: float64
基于时间索引的精确查找。查找索引为 2018 年 9 月 30 日的值。
In [25]:
ts["09/30/2018"]
Out[25]:
0.651825687842145
In [26]:
ts[datetime(2018, 9, 30)]
Out[26]:
0.651825687842145
基于索引的范围查找。查找索引时间在 2017 年内的所有记录。
In [27]:
ts["2017"]
Out[27]:
2017-10-01 0.493787
2017-10-08 -0.688910
2017-10-15 0.448156
2017-10-22 -1.042401
2017-10-29 -0.157431
2017-11-05 0.946544
2017-11-12 -0.009933
2017-11-19 1.809738
2017-11-26 0.780451
2017-12-03 -0.671147
2017-12-10 -1.085384
2017-12-17 -0.396987
2017-12-24 0.516356
2017-12-31 -1.339113
Freq: W-SUN, dtype: float64
查找索引时间在 2018 年 9 月内的所有记录。
In [28]:
ts["2018-9"]
Out[28]:
2018-09-02 0.654742
2018-09-09 0.924585
2018-09-16 -1.751716
2018-09-23 1.972103
2018-09-30 0.651826
Freq: W-SUN, dtype: float64
以时间段为索引的 DataFrame 对象的查找规则与以时间戳的相同。
In [29]:
ps
Out[29]:
| A | |
|---|---|
| 2017Q1 | 0.342835 |
| 2017Q2 | 0.774213 |
| 2017Q3 | 0.695786 |
| 2017Q4 | 0.032892 |
| 2018Q1 | 0.239562 |
| 2018Q2 | 0.116051 |
| 2018Q3 | 0.900067 |
| 2018Q4 | 0.270152 |
2018 年的第一个季度规定为 2017 年的 12 月初到 2018 年的 2 月末。
查找 2017 年内的所有季度的记录。
In [30]:
ps["2017"]
Out[30]:
| A | |
|---|---|
| 2017Q1 | 0.342835 |
| 2017Q2 | 0.774213 |
| 2017Q3 | 0.695786 |
| 2017Q4 | 0.032892 |
| 2018Q1 | 0.239562 |
查找 2017 年 12 月 31 日前的所有季度的记录。
In [31]:
ps[:datetime(2017, 12, 31)]
Out[31]:
| A | |
|---|---|
| 2017Q1 | 0.342835 |
| 2017Q2 | 0.774213 |
| 2017Q3 | 0.695786 |
| 2017Q4 | 0.032892 |
| 2018Q1 | 0.239562 |
查找 2018 年 6 月内的所有季度的记录。
In [32]:
ps["2018-06"]
Out[32]:
| A | |
|---|---|
| 2018Q3 | 0.900067 |
切片
使用 truncate() 切下 2017 年 11 月 26 日与 2018 年 4 月 29 日间的记录。
In [33]:
ts.truncate(before='11/26/2017', after='4/29/2018')
Out[33]:
2017-11-26 0.780451
2017-12-03 -0.671147
2017-12-10 -1.085384
2017-12-17 -0.396987
2017-12-24 0.516356
2017-12-31 -1.339113
2018-01-07 0.091994
2018-01-14 0.466957
2018-01-21 0.404413
2018-01-28 0.424614
2018-02-04 -1.523700
2018-02-11 -0.112411
2018-02-18 -0.742847
2018-02-25 -2.820375
2018-03-04 -1.026152
2018-03-11 0.249747
2018-03-18 -0.948177
2018-03-25 0.484366
2018-04-01 0.290852
2018-04-08 0.398359
2018-04-15 -0.632353
2018-04-22 -0.731030
2018-04-29 -0.443699
Freq: W-SUN, dtype: float64
移动
将时间索引 Series 中的值向后和向前移动。其方法是 shift()。
In [34]:
ts = ts[:5] # 取前 5 条数据方便观察。
ts
Out[34]:
2017-10-01 0.493787
2017-10-08 -0.688910
2017-10-15 0.448156
2017-10-22 -1.042401
2017-10-29 -0.157431
Freq: W-SUN, dtype: float64
将元素列向下移动一条。
In [35]:
ts.shift(1)
Out[35]:
2017-10-01 NaN
2017-10-08 0.493787
2017-10-15 -0.688910
2017-10-22 0.448156
2017-10-29 -1.042401
Freq: W-SUN, dtype: float64
除了元素可以被移动，索引本身也能被移动，需要加上 freq 参数。将索引列向上移动一条：
In [36]:
ts.shift(1, freq='W')
Out[36]:
2017-10-08 0.493787
2017-10-15 -0.688910
2017-10-22 0.448156
2017-10-29 -1.042401
2017-11-05 -0.157431
Freq: W-SUN, dtype: float64
重采样
重采样可以通俗得理解为改变时间索引的个数，通过增大或减小相邻索引的时间间隔以达到减小或增加索引数量的效果，在 Pandas 中使用 resample() 函数。
下采样：增大时间间隔，减少记录的数量。创建从 2018 年 10 月 1 日开始的日间隔索引的 Series 。
In [37]:
rng = pd.date_range('10/1/2018', periods=10, freq='D')
ts = pd.Series(np.random.randint(0, 50, len(rng)), index=rng)
ts
Out[37]:
2018-10-01 24
2018-10-02 9
2018-10-03 26
2018-10-04 37
2018-10-05 40
2018-10-06 32
2018-10-07 45
2018-10-08 22
2018-10-09 37
2018-10-10 8
Freq: D, dtype: int64
原先索引的日间隔被扩大为周间隔，并以周末为索引采样点，采样点的索引值为所有未被索引值的和。
In [38]:
ts.resample('W').sum()
Out[38]:
2018-10-07 213
2018-10-14 67
Freq: W-SUN, dtype: int64
同样也能使采样点的索引值为所有未被索引值的平均值。
In [39]:
ts.resample('W').mean()
Out[39]:
2018-10-07 30.428571
2018-10-14 22.333333
Freq: W-SUN, dtype: float64
使用 ohlc() 函数对所用未被采样值进行统计。
In [40]:
ts.resample('W').ohlc()
Out[40]:
| open | high | low | close | |
|---|---|---|---|---|
| 2018-10-07 | 24 | 45 | 9 | 45 |
| 2018-10-14 | 22 | 37 | 8 | 8 |
上采样：减小时间间隔频率，增加记录的数量。
原来间隔为日的索引列，间隔被缩小成 12 小时，增加采样点的值为空值。
In [41]:
ts.resample('12H').asfreq()
Out[41]:
2018-10-01 00:00:00 24.0
2018-10-01 12:00:00 NaN
2018-10-02 00:00:00 9.0
2018-10-02 12:00:00 NaN
2018-10-03 00:00:00 26.0
2018-10-03 12:00:00 NaN
2018-10-04 00:00:00 37.0
2018-10-04 12:00:00 NaN
2018-10-05 00:00:00 40.0
2018-10-05 12:00:00 NaN
2018-10-06 00:00:00 32.0
2018-10-06 12:00:00 NaN
2018-10-07 00:00:00 45.0
2018-10-07 12:00:00 NaN
2018-10-08 00:00:00 22.0
2018-10-08 12:00:00 NaN
2018-10-09 00:00:00 37.0
2018-10-09 12:00:00 NaN
2018-10-10 00:00:00 8.0
Freq: 12H, dtype: float64
ffill() 函数可以将新增的索引值以相邻的前一条索引值进行填充。
In [42]:
ts.resample('12H').ffill()
Out[42]:
2018-10-01 00:00:00 24
2018-10-01 12:00:00 24
2018-10-02 00:00:00 9
2018-10-02 12:00:00 9
2018-10-03 00:00:00 26
2018-10-03 12:00:00 26
2018-10-04 00:00:00 37
2018-10-04 12:00:00 37
2018-10-05 00:00:00 40
2018-10-05 12:00:00 40
2018-10-06 00:00:00 32
2018-10-06 12:00:00 32
2018-10-07 00:00:00 45
2018-10-07 12:00:00 45
2018-10-08 00:00:00 22
2018-10-08 12:00:00 22
2018-10-09 00:00:00 37
2018-10-09 12:00:00 37
2018-10-10 00:00:00 8
Freq: 12H, dtype: int64
时间的算术方法
常用时间的算术规则
下表是 Pandas 内建的一些时间类，常用于时间索引的位移。
首先要导入 pandas.tseries.offsets 模块，Pandas 所有常用时间类都在该模块中。
In [43]:
d = pd.Timestamp(2018, 10, 1, 10, 1, 1)
d
Out[43]:
Timestamp('2018-10-01 10:01:01')
使用 DateOffset() 实现时间戳位移。
向后移动一个月零两天。
In [44]:
from pandas.tseries.offsets import DateOffset
d + DateOffset(months=1, days=2)
Out[44]:
Timestamp('2018-11-03 10:01:01')
也可以用时间戳加减常用时间类以实现时间戳位移。向前移动 10 个工作日。
In [45]:
from pandas.tseries.offsets import BDay
d - 10 * BDay()
Out[45]:
Timestamp('2018-09-17 10:01:01')
向后移动一个月末。
In [47]:
from pandas.tseries.offsets import BMonthEnd
d + BMonthEnd()
Out[47]:
Timestamp('2018-10-31 10:01:01')
个性化定制日期。虽然日历规定年末是 12 月，加入参数后相当于人为规定 2 月是年末。
向后移动到上两个年末。
In [48]:
from pandas.tseries.offsets import YearEnd
d + YearEnd(month=2)
Out[48]:
Timestamp('2019-02-28 10:01:01')
向前移动到上一个周四。
In [49]:
from pandas.tseries.offsets import Week
d - Week(weekday=4)
Out[49]:
Timestamp('2018-09-28 10:01:01')
可以使用 rollforward() 将指定时间向前或向后移动到一个制定常用时间类的时间戳上。将时间移动到下一个月末：
In [50]:
offset = BMonthEnd()
offset.rollforward(d)
Out[50]:
Timestamp('2018-10-31 10:01:01')
将时间移动到上一个月末。
In [51]:
offset.rollback(d)
Out[51]:
Timestamp('2018-09-28 10:01:01')
偏移也同样适用于时间索引
In [52]:
rng
Out[52]:
DatetimeIndex(['2018-10-01', '2018-10-02', '2018-10-03', '2018-10-04',
'2018-10-05', '2018-10-06', '2018-10-07', '2018-10-08',
'2018-10-09', '2018-10-10'],
dtype='datetime64[ns]', freq='D')
所有的时间索引向后移动两日。
In [53]:
rng + DateOffset(days=2)
Out[53]:
DatetimeIndex(['2018-10-03', '2018-10-04', '2018-10-05', '2018-10-06',
'2018-10-07', '2018-10-08', '2018-10-09', '2018-10-10',
'2018-10-11', '2018-10-12'],
dtype='datetime64[ns]', freq='D')
所有的时间索引向后移动两个工作日。
In [54]:
rng + 2*BDay()
Out[54]:
DatetimeIndex(['2018-10-03', '2018-10-04', '2018-10-05', '2018-10-08',
'2018-10-09', '2018-10-09', '2018-10-09', '2018-10-10',
'2018-10-11', '2018-10-12'],
dtype='datetime64[ns]', freq=None)
所有的时间索引向后移动 15 分钟。
In [55]:
from pandas.tseries.offsets import Minute
rng + Minute(15)
Out[55]:
DatetimeIndex(['2018-10-01 00:15:00', '2018-10-02 00:15:00',
'2018-10-03 00:15:00', '2018-10-04 00:15:00',
'2018-10-05 00:15:00', '2018-10-06 00:15:00',
'2018-10-07 00:15:00', '2018-10-08 00:15:00',
'2018-10-09 00:15:00', '2018-10-10 00:15:00'],
dtype='datetime64[ns]', freq='D')
下列是常用时间系列频率参数，上面小节经常出现，现在以一个表格作详细说明。
| 参数名 | 说明 |
|---|---|
| B | 工作日频率 |
| C | 定制工作日频率 |
| D | 日历日频率 |
| W | 每周频率 |
| M | 月结束频率 |
| SM | 半月结束频率(15 个月和月末) |
| BM | 业务月末频率 |
| CBM | 定制业务月末频率 |
| MS | 月起始频率 |
| sMs | 半月起始频率(第 1 和 15) |
| BMS | 业务月开始频率 |
| CBMS | 定制商业月份开始频率 |
| Q | 四分频结束频率 |
| BQ | 业务四分之一频率 |
| QS | 四分频启动频率 |
| BQS | 业务季开始频率 |
| A | 年结束频率 |
| BA | 业务年结束频率 |
| AS | 年起始频率 |
| BAS | 业务年开始频率 |
| BH | 工作时间频率 |
| H | 每小时频率 |
| T, min | 分钟频率 |
| S | 次频 |
| L, ms | 毫秒 |
| U, uS | 微秒 |
| N | 纳秒 |
使用常用频率参数组合创建时间索引。
创建 10 条以 2018 年 10 月 1 日为开始，间隔为 1 天 1 小时 1 分钟 10 微秒的时间索引。
In [ ]:
pd.date_range("2018-10-1", periods=10, freq='1D1H1min10U')
In [ ]:
以下频率参数可以指定后缀以达到改变默认间隔点的效果。
创建 10 条以 2018 年 10 月 1 日为开始，间隔为每周三的时间索引。
In [56]:
pd.date_range("2018-10-1", periods=10, freq='W-WED')
Out[56]:
DatetimeIndex(['2018-10-03', '2018-10-10', '2018-10-17', '2018-10-24',
'2018-10-31', '2018-11-07', '2018-11-14', '2018-11-21',
'2018-11-28', '2018-12-05'],
dtype='datetime64[ns]', freq='W-WED')
在使用特定频率（MonthEnd，MonthBegin，WeekEnd 等）的参数时，如果起始时间是刚好在频率点上，使用 n参数可以决定是否让该点参与计算。
n=1 时参与计算。
In [57]:
from pandas.tseries.offsets import MonthBegin
pd.Timestamp('2018-10-1') + MonthBegin(n=1)
Out[57]:
Timestamp('2018-11-01 00:00:00')
n=0 时不参与计算。
In [58]:
pd.Timestamp('2018-10-1') + MonthBegin(n=0)
Out[58]:
Timestamp('2018-10-01 00:00:00')
下采样聚合
下采样中的聚合是指下采样后，对未被采样到的点进行的一系列计算。
创建 100 个日历日为时间索引的 DataFrame，将其以月频率下采样。
In [59]:
df = pd.DataFrame(np.random.rand(100, 3),
index=pd.date_range('10/1/2018', freq='D', periods=100),
columns=['A', 'B', 'C'])
r = df.resample('M')
r
Out[59]:
DatetimeIndexResampler [freq=<MonthEnd>, axis=0, closed=right, label=right, convention=start, base=0]
对未采样点求和，结果保存在采样点的值中。
In [60]:
r.sum()
Out[60]:
| A | B | C | |
|---|---|---|---|
| 2018-10-31 | 15.831843 | 15.593403 | 13.834875 |
| 2018-11-30 | 16.388360 | 14.547544 | 16.558796 |
| 2018-12-31 | 17.184591 | 14.223076 | 16.141872 |
| 2019-01-31 | 4.254840 | 4.041291 | 5.459201 |
在下采样后也能进行查找操作。选择 A、C 列后取均值计算。
In [61]:
r[['A', 'C']].mean()
Out[61]:
| A | C | |
|---|---|---|
| 2018-10-31 | 0.510705 | 0.446286 |
| 2018-11-30 | 0.546279 | 0.551960 |
| 2018-12-31 | 0.554342 | 0.520706 |
| 2019-01-31 | 0.531855 | 0.682400 |
使用 agg() 同时进行不同的计算。对采样结果进行取和与取均值计算。
In [62]:
r.agg([np.sum, np.mean])
Out[62]:
| A | B | C | ||||
|---|---|---|---|---|---|---|
| sum | mean | sum | mean | sum | mean | |
| 2018-10-31 | 15.831843 | 0.510705 | 15.593403 | 0.503013 | 13.834875 | 0.446286 |
| 2018-11-30 | 16.388360 | 0.546279 | 14.547544 | 0.484918 | 16.558796 | 0.551960 |
| 2018-12-31 | 17.184591 | 0.554342 | 14.223076 | 0.458809 | 16.141872 | 0.520706 |
| 2019-01-31 | 4.254840 | 0.531855 | 4.041291 | 0.505161 | 5.459201 | 0.682400 |
选择 A 列，同时进行取和，取均值，取标准差计算。
In [63]:
r['A'].agg([np.sum, np.mean, np.std])
Out[63]:
| sum | mean | std | |
|---|---|---|---|
| 2018-10-31 | 15.831843 | 0.510705 | 0.284486 |
| 2018-11-30 | 16.388360 | 0.546279 | 0.319620 |
| 2018-12-31 | 17.184591 | 0.554342 | 0.310248 |
| 2019-01-31 | 4.254840 | 0.531855 | 0.312737 |
对 A 列求和与标准差，对 B 列求均值与标准差。
In [64]:
r.agg({'A': ['sum', 'std'], 'B': ['mean', 'std']})
Out[64]:
| A | B | |||
|---|---|---|---|---|
| sum | std | mean | std | |
| 2018-10-31 | 15.831843 | 0.284486 | 0.503013 | 0.272411 |
| 2018-11-30 | 16.388360 | 0.319620 | 0.484918 | 0.301132 |
| 2018-12-31 | 17.184591 | 0.310248 | 0.458809 | 0.328539 |
| 2019-01-31 | 4.254840 | 0.312737 | 0.505161 | 0.259380 |
实验总结
本章节介绍了 Pandas 对时间序列数据的基本处理操作。重点演示了时间的创建、时间索引对象的处理、时间的相关计算。当然，文中对这些方法的介绍依然还不够详细。如果你需要在实际工作中进行更复杂的时间数据处理，还需要深刻理解文中的基本演示，改编或组合出更高级的功能，这样才能发挥出 Pandas 的强大作用。
Markdown Code
继续学习
©️ 本课程内容，由作者授权实验楼发布，未经允许，禁止转载、下载及非法传播。
