利用Python进行数据分析-Pandas(第七部分-时间序列)

　　时间序列（time series）数据是一种重要的结构化数据形式，应用于多个领域，包括金融学、经济学、生态学、神经科学、物理学等。时间序列数据的意义取决于具体的应用场景，主要有以下几种：

  • 时间戳（timestamp），特定的时刻。
  • 固定时期（period），如2007年1月或2010年全年。
  • 时间间隔（interval），由起始和结束时间戳表示。时期（period）可以被看做间隔（interval）的特例。
  • 实验或过程时间，每个时间点都是相对于特定起始时间的一个度量。例如，从放入烤箱时起，每秒钟饼干的直径。

1、日期和时间数据类型及工具

　　Python标准库包含用于日期（date）和时间（time）数据的数据类型，而且还有日历方面的功能。我们主要会用到datetime、time以及calendar模块。datetime.datetime（也可以简写为datetime）是用得最多的数据类型：

from datetime import datetime
now = datetime.now()
print(now)
?
1
2019-12-18 21:12:15.833302
print(now.year, now.month, now.day)
?
1
2019 12 18

datetime以毫秒形式存储日期和时间。timedelta表示两个datetime对象之间的时间差：

delta = datetime(2011, 1, 7) - datetime(2008, 6, 24, 8, 15)
print(delta.days)
print(delta.seconds)
?
1
2
926
56700

可以给datetime对象加上（或减去）一个或多个timedelta，这样会产生一个新对象：

from datetime import timedelta
start = datetime(2011, 1, 7)
print(start + timedelta(12))
?
1
2011-01-19 00:00:00
print(start - 2 * timedelta(12))
?
1
2010-12-14 00:00:00

datetime模块中的数据类型参见如下表，虽然本章主要讲的是pandas数据类型和高级时间序列处理，但你肯定会在Python的其他地方遇到有关datetime的数据类型。

类型 说明
date 以公历形式存储日历日期（年、月、日）
time 将时间存储为时、分、秒、毫秒
datetime 存储日期和时间
timedelta 表示两个datetime值之间的差（日、秒、毫秒）

2、字符串和datetime的相互转换

　　利用str或strftime方法（传入一个格式化字符串），datetime对象和pandas的Timestamp对象可以被格式化为字符串：

stamp = datetime(2011, 1, 3)
print(str(stamp))
?
1
2011-01-03 00:00:00
print(stamp.strftime('%Y-%m-%d'))
?
1
2011-01-03

如下表列出了全部的格式化编码：（datetime格式定义）

代码 说明
%Y 4位数的年
%y 2位数的年
%m 2位数的月[01, 12]
%d 2位数的日[01, 31]
%H 时（24小时制）[00, 23]
%l 时（12小时制）[01, 12]
%M 2位数的分[00, 59]
%S 秒[00, 61]（秒60和61用于闰秒）
%w 用整数表示的星期几[0 (星期天), 6]
%U 每年的第几周[00， 53]。星期天被认为是每周的第一天，每年第一个星期天之前的那几天被认为是"第0周"
%W 每年的第几周[00， 53]。星期一被认为是每周的第一天，每年第一个星期天之前的那几天被认为是"第0周"
%z 以+HHMM或-HHMM表示的UTC时区偏移量，如果时区为native，则返回空字符串。
%F %Y-%m-%d简写形式，例如2012-4-18
%D %m/%d/%y简写形式，例如04/18/12

datetime.strptime可以用这些格式化编码将字符串转换为日期：

value = '2011-01-03'
print(datetime.strptime(value, '%Y-%m-%d'))
?
1
2011-01-03 00:00:00
datestrs = ['7/6/2011', '8/6/2011']
print([datetime.strptime(x, '%m/%d/%Y') for x in datestrs])
?
1
[datetime.datetime(2011, 7, 6, 0, 0), datetime.datetime(2011, 8, 6, 0, 0)]

datetime.strptime是通过已知格式日期解析的最佳方式。但是每次都要编写格式定义是很麻烦的事情，尤其是对于一些常见的日期格式。这种情况下，你可以用dateutil这个第三方包中的parser.parse方法：

from dateutil.parser import parse
print(parse('2011-01-03'))
?
1
2011-01-03 00:00:00

dateutil可以解析几乎所有人类能够理解的日期表示形式：

print(parse('Jan 31, 1997 10:45 PM'))
?
1
1997-01-31 22:45:00

在国际通用的格式中，日出现在月的前面很普遍，传入dayfirst=True即可解决这个问题：

print(parse('6/12/2011', dayfirst=True))
?
1
2011-12-06 00:00:00

pandas通常是用于处理成组日期的，不管这些日期是DataFrame的轴索引还是列。to_datetime方法可以解析多种不同的日期表示形式。对标准日期格式的解析非常快：

datestrs = ['2011-07-06 12:00:00', '2011-08-06 00:00:00']
print(pd.to_datetime(datestrs))
?
1
DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00'], dtype='datetime64[ns]', freq=None)

它还可以处理缺失值（None、空字符串等）：

idx = pd.to_datetime(datestrs + [None])
print(idx)
?
1
DatetimeIndex(['2011-07-06 12:00:00', '2011-08-06 00:00:00', 'NaT'], dtype='datetime64[ns]', freq=None)
print(idx[2])
?
1
NaT
print(pd.isnull(idx))
?
1
[False False  True]

NaT（Not a Time）是pandas中时间戳数据的null值。

注意：dateutil.parser是一个实用但不完美的工具。比如说，它会把一些原本不是日期的字符串认作是日期（比如"42"会被解析为2042年的今天）。

datetime对象还有一些特定于当前环境（位于不同国家或使用不同语言的系统）的格式化选项。例如，德语或法语系统所使用的月份简写就与英语系统所使用的不同。如下表进行了总结：

代码 说明
%a 星期几的简写
%A 星期几的全称
%b 月份的简写
%B 月份的全称
%c 完整的日期和时间
%p 不同环境中的AM或PM
%x 适用于当前环境的日期格式
%X 适用于当前环境的时间格式

3、时间序列基础

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

from datetime import datetime
dates = [datetime(2011, 1, 2), datetime(2011, 1, 5), datetime(2011, 1, 7), datetime(2011, 1, 8), datetime(2011, 1, 10), datetime(2011, 1, 12)]
np.random.seed(100)
ts = pd.Series(np.random.randn(6), index=dates)
print(ts)
?
1
2
3
4
5
6
7
2011-01-02   -1.749765
2011-01-05    0.342680
2011-01-07    1.153036
2011-01-08   -0.252436
2011-01-10    0.981321
2011-01-12    0.514219
dtype: float64

这些datetime对象实际上是被放在一个DateTimeIndex中的：

print(ts.index)
?
1
2
3
DatetimeIndex(['2011-01-02', '2011-01-05', '2011-01-07', '2011-01-08',
               '2011-01-10', '2011-01-12'],
              dtype='datetime64[ns]', freq=None)

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

print(ts + ts[::2])
?
1
2
3
4
5
6
7
2011-01-02   -3.499531
2011-01-05         NaN
2011-01-07    2.306072
2011-01-08         NaN
2011-01-10    1.962642
2011-01-12         NaN
dtype: float64

ts[::2]是每隔两个取一个：

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

print(ts.index.dtype)
?
1
datetime64[ns]

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

stamp = ts.index[0]
print(stamp)
?
1
2011-01-02 00:00:00

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

4、索引、选取、子集构造

　　当你根据标签索引选取数据时，时间序列和其他的pandas.Series很像：

stamp = ts.index[2]
print(ts[stamp])
?
1
1.153035802563644

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

print(ts['1/10/2011'])
print(ts['20110110'])
?
1
2
0.9813207869512316
0.9813207869512316

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

longer_ts = pd.Series(np.random.rand(1000), index=pd.date_range('1/1/2000', periods=1000))
print(longer_ts)
?
1
2
3
4
5
6
7
8
9
10
11
12
2000-01-01    0.136707
2000-01-02    0.575093
2000-01-03    0.891322
2000-01-04    0.209202
2000-01-05    0.185328
                ...  
2002-09-22    0.222199
2002-09-23    0.305126
2002-09-24    0.819320
2002-09-25    0.578470
2002-09-26    0.027617
Freq: D, Length: 1000, dtype: float64
print(longer_ts['2001'])
?
1
2
3
4
5
6
7
8
9
10
11
12
2001-01-01    0.554477
2001-01-02    0.647167
2001-01-03    0.185474
2001-01-04    0.271978
2001-01-05    0.148439
                ...  
2001-12-27    0.171820
2001-12-28    0.709574
2001-12-29    0.489323
2001-12-30    0.441921
2001-12-31    0.646576
Freq: D, Length: 365, dtype: float64

这里，字符串"2001"被解释成年，并根据它选取时间间区。指定月也同样奏效：

print(longer_ts['2001-05'])
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
2001-05-01    0.519338
2001-05-02    0.343333
2001-05-03    0.658773
2001-05-04    0.282790
2001-05-05    0.502466
2001-05-06    0.303278
2001-05-07    0.552529
2001-05-08    0.161127
2001-05-09    0.568549
2001-05-10    0.485710
2001-05-11    0.127520
2001-05-12    0.543692
2001-05-13    0.200491
2001-05-14    0.670161
2001-05-15    0.558112
2001-05-16    0.232378
2001-05-17    0.515588
2001-05-18    0.314992
2001-05-19    0.846593
2001-05-20    0.447376
2001-05-21    0.100085
2001-05-22    0.901592
2001-05-23    0.856088
2001-05-24    0.286330
2001-05-25    0.259015
2001-05-26    0.066371
2001-05-27    0.317632
2001-05-28    0.051843
2001-05-29    0.944188
2001-05-30    0.717217
2001-05-31    0.553659
Freq: D, dtype: float64

datetime对象也可以进行切片：

print(ts[datetime(2011, 1, 7):])
?
1
2
3
4
5
2011-01-07    1.153036
2011-01-08   -0.252436
2011-01-10    0.981321
2011-01-12    0.514219
dtype: float64

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

print(ts['1/6/2011': '1/11/2011'])
?
1
2
3
4
2011-01-07    1.153036
2011-01-08   -0.252436
2011-01-10    0.981321
dtype: float64

跟之前一样，你可以传入字符串日期、datetime或Timestamp。注意，这样切片所产生的是源时间序列的视图，跟NumPy数组的切片运算是一样的。

这意味着，没有数据被复制，对切片进行修改会反映到原始数据上。

此外，还有一个等价的实例方法也可以截取两个日期之间TimeSeries：

print(ts.truncate(after='1/9/2011'))
?
1
2
3
4
5
2011-01-02   -1.749765
2011-01-05    0.342680
2011-01-07    1.153036
2011-01-08   -0.252436
dtype: float64

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

dates = pd.date_range('1/1/2000', periods=100, freq='W-WED')
long_df = pd.DataFrame(np.random.randn(100, 4), index=dates, columns=['Colorado', 'Texas', 'New York', 'Ohio'])
print(long_df.loc['5-2001'])
?
1
2
3
4
5
6
            Colorado     Texas  New York      Ohio
2001-05-02 -0.760450 -0.681422  0.214538 -0.202777
2001-05-09 -0.598398  0.482774  0.336462  1.985490
2001-05-16  0.361157 -3.678247  0.942566 -1.924416
2001-05-23  0.575417  0.601643  0.173806 -1.235230
2001-05-30 -0.566415  0.247651  0.950964  0.367511

5、带有重复索引的时间序列

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

dates = pd.DatetimeIndex(['1/1/2000', '1/2/2000', '1/2/2000', '1/2/2000', '1/3/2000'])
dup_ts = pd.Series(np.arange(5), index=dates)
print(dup_ts)
?
1
2
3
4
5
6
2000-01-01    0
2000-01-02    1
2000-01-02    2
2000-01-02    3
2000-01-03    4
dtype: int32

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

print(dup_ts.index.is_unique)
?
1
False

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

print(dup_ts['1/3/2000'])
?
1
4
print(dup_ts['1/2/2000'])
?
1
2
3
4
2000-01-02    1
2000-01-02    2
2000-01-02    3
dtype: int32

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

grouped = dup_ts.groupby(level=0)
print(grouped.mean())
?
1
2
3
4
2000-01-01    0
2000-01-02    2
2000-01-03    4
dtype: int32
print(grouped.count())
?
1
2
3
4
2000-01-01    1
2000-01-02    3
2000-01-03    1
dtype: int64

6、日期的范围、频率以及移动

　　pandas中的原生时间序列一般被认为是不规则的，也就是说，它们没有固定的频率。对于大部分应用程序而言，这是无所谓的。但是，它常常需要以某种相对固定的频率进行分析，比如每日、每月、每15分钟等（这样自然会在时间序列中引入缺失值）。幸运的是，pandas有一整套标准时间序列频率以及用于重采样、频率推断、生成固定频率日期范围的工具。例如，我们可以将之前那个时间序列转换为一个具有固定频率（每日）的时间序列，只需要调用resample即可：

resampler = ts.resample('D')

字符串"D"是每天的意思。

频率的转换（或重采样）是一个比较重大的问题，稍后将专门用一节来进行讨论。这里，我将告诉你如何使用基本的频率和它的倍数。

7、生成日期范围

　　虽然我之前用的时候没有明说，但你可能已经猜到pandas.date_range可用于根据指定的频率生成指定长度的DatetimeIndex：

index = pd.date_range('2012-04-01', '2012-06-01')
print(index)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
               '2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
               '2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
               '2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
               '2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20',
               '2012-04-21', '2012-04-22', '2012-04-23', '2012-04-24',
               '2012-04-25', '2012-04-26', '2012-04-27', '2012-04-28',
               '2012-04-29', '2012-04-30', '2012-05-01', '2012-05-02',
               '2012-05-03', '2012-05-04', '2012-05-05', '2012-05-06',
               '2012-05-07', '2012-05-08', '2012-05-09', '2012-05-10',
               '2012-05-11', '2012-05-12', '2012-05-13', '2012-05-14',
               '2012-05-15', '2012-05-16', '2012-05-17', '2012-05-18',
               '2012-05-19', '2012-05-20', '2012-05-21', '2012-05-22',
               '2012-05-23', '2012-05-24', '2012-05-25', '2012-05-26',
               '2012-05-27', '2012-05-28', '2012-05-29', '2012-05-30',
               '2012-05-31', '2012-06-01'],
              dtype='datetime64[ns]', freq='D')

默认情况下，date_range会产生按天计算的时间点。如果只传入起始或结束日期，那就还得传入一个表示一段时间的数字：

print(pd.date_range(start='2012-04-01', periods=20))
?
1
2
3
4
5
6
DatetimeIndex(['2012-04-01', '2012-04-02', '2012-04-03', '2012-04-04',
               '2012-04-05', '2012-04-06', '2012-04-07', '2012-04-08',
               '2012-04-09', '2012-04-10', '2012-04-11', '2012-04-12',
               '2012-04-13', '2012-04-14', '2012-04-15', '2012-04-16',
               '2012-04-17', '2012-04-18', '2012-04-19', '2012-04-20'],
              dtype='datetime64[ns]', freq='D')
print(pd.date_range(end='2012-06-01', periods=20))
?
1
2
3
4
5
6
DatetimeIndex(['2012-05-13', '2012-05-14', '2012-05-15', '2012-05-16',
               '2012-05-17', '2012-05-18', '2012-05-19', '2012-05-20',
               '2012-05-21', '2012-05-22', '2012-05-23', '2012-05-24',
               '2012-05-25', '2012-05-26', '2012-05-27', '2012-05-28',
               '2012-05-29', '2012-05-30', '2012-05-31', '2012-06-01'],
              dtype='datetime64[ns]', freq='D')

起始和结束日期定义了日期索引的严格边界。例如，如果你想要生成一个由每月最后一个工作日组成的日期索引，可以传入"BM"频率（表示business end of month），这样就只会包含时间间隔内（或刚好在边界上的）符合频率要求的日期：

print(pd.date_range('2000-01-01', '2000-12-01', freq='BM'))
?
1
2
3
4
DatetimeIndex(['2000-01-31', '2000-02-29', '2000-03-31', '2000-04-28',
               '2000-05-31', '2000-06-30', '2000-07-31', '2000-08-31',
               '2000-09-29', '2000-10-31', '2000-11-30'],
              dtype='datetime64[ns]', freq='BM')

如下列表列出了基本的时间序列频率：

别名 偏移量类型 说明
D Day 每日历日
B BusinessDay 每工作日
H Hour 每小时
T或min Minute 每分
S Second 每秒
L或ms Milli 每毫秒（即每千分之一秒）
U Micro 每微妙（即每百万分之一秒）
M MonthEnd 每月最后一个日历日
BM BusinessMonthEnd 每月最后一个工作日
MS MonthBegin 每月第一个日历日
BMS BusinessMonthBegin 每月第一个工作日
W-MON、W-TUE... Week 从指定的星期几（MON、TUE、...SUN）开始算起，每周
WOM-1MON、WOM-2MON WeekOfMonth 产生每月第一、第二、第三或第四周的星期几。例如，WOM-3FRI表示每月第三个星期五
Q-JAN、Q-FEB... QuarterEnd 对于以指定月份（JAN、FEB、...DEC）结束的年度，每季度最后一月的最后一个日历日
BQ-JAN、BQ-FEB BusinessQuarterEnd 对于以指定月份结束的年度，每季度最后一月的最后一个工作日
QS-JAN、QS-FEB QuarterBegin 对于以指定月份结束的年度，每季度最后一月的第一个日历日
BQS-JAN、BQS-FEB BussinessQuarterBegin 对于以指定月份结束的年度，每季度最后一月的第一个工作日
A-JAN、A-FEB YearEnd 每年指定月份（JAN、FEB...DEC）的最后一个日历日
BA-JAN、BA-FEB BusinessYearEnd 每年指定月份的最后一个工作日
AS-JAN、AS-FEB YearBegin 每年指定月份的第一个日历日
BAS-JAN、BAS-FEB BusinessYearBegin 每年指定月份的第一个工作日

date_range默认会保留起始和结束时间戳的时间信息：

print(pd.date_range('2012-05-02 12:56:31', periods=5))
?
1
2
3
4
DatetimeIndex(['2012-05-02 12:56:31', '2012-05-03 12:56:31',
               '2012-05-04 12:56:31', '2012-05-05 12:56:31',
               '2012-05-06 12:56:31'],
              dtype='datetime64[ns]', freq='D')

有时，虽然起始和结束日期带有时间信息，但你希望产生一组被规范化到午夜的时间戳。normalize选项即可实现该功能：

print(pd.date_range('2012-05-02 12:56:31', periods=5, normalize=True))
?
1
2
3
DatetimeIndex(['2012-05-02', '2012-05-03', '2012-05-04', '2012-05-05',
               '2012-05-06'],
              dtype='datetime64[ns]', freq='D')

8、频率和日期偏移量

　　pandas中的频率是由一个基础频率（base frequency）和一个乘数组成的。基础频率通常以一个字符串别名表示，比如"M"表示每月，"H"表示每小时。对于每个基础频率，都有一个被称为日期偏移量（date offset）的对象与之对应。例如，按小时计算的频率都可以用Hour类表示：

from pandas.tseries.offsets import Hour, Minute
hour = Hour()
print(hour)
?
1
<Hour>

传入一个整数即可定义偏移量的倍数：

four_hours = Hour(4)
print(four_hours)
?
1
<4 * Hours>

一般来说，无需明确创建这样的对象，只需使用诸如"H"或"4H"这样的字符串别名即可。在基础频率前面放上一个整数即可创建倍数：

print(pd.date_range('2000-01-01', '2000-01-03 23:59', freq='4h'))
?
1
2
3
4
5
6
7
8
9
10
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 04:00:00',
               '2000-01-01 08:00:00', '2000-01-01 12:00:00',
               '2000-01-01 16:00:00', '2000-01-01 20:00:00',
               '2000-01-02 00:00:00', '2000-01-02 04:00:00',
               '2000-01-02 08:00:00', '2000-01-02 12:00:00',
               '2000-01-02 16:00:00', '2000-01-02 20:00:00',
               '2000-01-03 00:00:00', '2000-01-03 04:00:00',
               '2000-01-03 08:00:00', '2000-01-03 12:00:00',
               '2000-01-03 16:00:00', '2000-01-03 20:00:00'],
              dtype='datetime64[ns]', freq='4H')

大部分偏移量对象都可通过加法进行连接：

print(Hour(2) + Minute(30))
?
1
<150 * Minutes>

同理，你也可以传入频率字符串（如"2h30min"），这种字符串可以被高效地解析等效的表达式：

print(pd.date_range('2000-01-01', periods=10, freq='1h30min'))
?
1
2
3
4
5
6
DatetimeIndex(['2000-01-01 00:00:00', '2000-01-01 01:30:00',
               '2000-01-01 03:00:00', '2000-01-01 04:30:00',
               '2000-01-01 06:00:00', '2000-01-01 07:30:00',
               '2000-01-01 09:00:00', '2000-01-01 10:30:00',
               '2000-01-01 12:00:00', '2000-01-01 13:30:00'],
              dtype='datetime64[ns]', freq='90T')

有些频率所描述的时间点并不是均匀分割的。例如，"M"（日历月末）和"BM"（每月最后一个工作日）就取决于每月的天数，对于后者，还要考虑月末是不是周末。由于没有更好的术语，我将这些称为锚点偏移量（anchored offset）。

9、WOM日期

　　WOM（Week Of Month）是一种非常实用的频率类，它以WOM开头。它使你能获得诸如"每月第三个星期五"之类的日期：

rng = pd.date_range('2012-01-01', '2012-09-01', freq='WOM-3FRI')
print(list(rng))
?
1
[Timestamp('2012-01-20 00:00:00', freq='WOM-3FRI'), Timestamp('2012-02-17 00:00:00', freq='WOM-3FRI'), Timestamp('2012-03-16 00:00:00', freq='WOM-3FRI'),<br> Timestamp('2012-04-20 00:00:00', freq='WOM-3FRI'), Timestamp('2012-05-18 00:00:00', freq='WOM-3FRI'), Timestamp('2012-06-15 00:00:00', freq='WOM-3FRI'), <br>Timestamp('2012-07-20 00:00:00', freq='WOM-3FRI'), Timestamp('2012-08-17 00:00:00', freq='WOM-3FRI')]

10、移动（超前和滞后）数据

　　移动（shifting）指的是沿着时间轴将数据前移或后移。Series和DataFrame都有一个shift方法用于执行单纯的前移或后移操作，保持索引不变：

np.random.seed(100)
ts = pd.Series(np.random.randn(4), index=pd.date_range('1/1/2000', periods=4, freq='M'))
print(ts)
?
1
2
3
4
5
2000-01-31   -1.749765
2000-02-29    0.342680
2000-03-31    1.153036
2000-04-30   -0.252436
Freq: M, dtype: float64
print(ts.shift(2))
?
1
2
3
4
5
2000-01-31         NaN
2000-02-29         NaN
2000-03-31   -1.749765
2000-04-30    0.342680
Freq: M, dtype: float64
print(ts.shift(-2))
?
1
2
3
4
5
2000-01-31    1.153036
2000-02-29   -0.252436
2000-03-31         NaN
2000-04-30         NaN
Freq: M, dtype: float64

当我们这样进行移动时，就会在时间序列的前面或后面产生缺失数据。

shift通常用于计算一个时间序列或多个时间序列（如DataFrame的列）中的百分比变化。可以这样表达：

print(ts/ts.shift(1)-1)
?
1
2
3
4
5
2000-01-31         NaN
2000-02-29   -1.195844
2000-03-31    2.364756
2000-04-30   -1.218932
Freq: M, dtype: float64

由于单纯的移位操作不会修改索引，所以部分数据会被丢弃。因此，如果频率已知，则可以将其传给shift以便实现对时间戳进行位移而不是对数据进行简单位移：

print(ts.shift(2, freq='M'))
?
1
2
3
4
5
2000-03-31   -1.749765
2000-04-30    0.342680
2000-05-31    1.153036
2000-06-30   -0.252436
Freq: M, dtype: float64

这里还可以使用其他频率，于是你就能非常灵活地对数据进行超前和滞后处理了：

print(ts.shift(3, freq='D'))
?
1
2
3
4
5
2000-02-03   -1.749765
2000-03-03    0.342680
2000-04-03    1.153036
2000-05-03   -0.252436
dtype: float64
print(ts.shift(1, freq='90T'))
?
1
2
3
4
5
2000-01-31 01:30:00   -1.749765
2000-02-29 01:30:00    0.342680
2000-03-31 01:30:00    1.153036
2000-04-30 01:30:00   -0.252436
Freq: M, dtype: float64

11、通过偏移量对日期进行位移

　　pandas的日期偏移量还可以用在datetime或Timestamp对象上：

from pandas.tseries.offsets import Day, MonthEnd
now = datetime(2011, 11, 17)
print(now + 3 * Day())
?
1
2011-11-20 00:00:00

如果加的是锚点偏移量（比如MonthEnd），第一次增量会将原日期向前滚动到符合频率规则的下一个日期：

print(now + MonthEnd())
?
1
2011-11-30 00:00:00
print(now + MonthEnd(2))
?
1
2011-12-31 00:00:00

通过锚点偏移量的rollforward和rollback方法，可明确地将日期向前或向后"滚动"：

print(offset.rollforward(now))
?
1
2011-11-30 00:00:00
print(offset.rollback(now))
?
1
2011-10-31 00:00:00

日期偏移量还有一个巧妙的用法，即结合groupBy使用这两个"滚动"方法：

ts = pd.Series(np.random.rand(20), index=pd.date_range('1/15/2000', periods=20, freq='4d'))
print(ts)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2000-01-15    0.543405
2000-01-19    0.278369
2000-01-23    0.424518
2000-01-27    0.844776
2000-01-31    0.004719
2000-02-04    0.121569
2000-02-08    0.670749
2000-02-12    0.825853
2000-02-16    0.136707
2000-02-20    0.575093
2000-02-24    0.891322
2000-02-28    0.209202
2000-03-03    0.185328
2000-03-07    0.108377
2000-03-11    0.219697
2000-03-15    0.978624
2000-03-19    0.811683
2000-03-23    0.171941
2000-03-27    0.816225
2000-03-31    0.274074
Freq: 4D, dtype: float64
print(ts.groupby(offset.rollforward).mean())
?
1
2
3
4
2000-01-31    0.419157
2000-02-29    0.490071
2000-03-31    0.445744
dtype: float64

当然，更简单、更快速地实现该功能的办法是使用resample：

print(ts.resample('M').mean())
?
1
2
3
4
2000-01-31    0.419157
2000-02-29    0.490071
2000-03-31    0.445744
Freq: M, dtype: float64

12、时区处理

　　时间序列处理工作中最让人不爽的就是对时区的处理。许多人都选择以协调世界时（UTC，它是格林尼治标准时间（Greenwich Mean Time）的接替者，目前已经是国际标准了）来处理时间序列。时区是以UTC偏移量的形式表示的。例如夏令期间，纽约比UTC慢4小时，而在全年其他时间则比UTC慢5小时。

　　在Python中，时区信息来自第三方库pytz，它使Python可以使用Olson数据库（汇编了世界时区信息）。这对历史数据非常重要，这是因为由于各地政府的各种突发奇想，夏令时转变日期（甚至UTC偏移量）已经发生过多次改变了。就拿美国来说，DST转变时间自1900年以来就改变过多次！

import pytz
print(pytz.common_timezones[-5:])
?
1
['US/Eastern', 'US/Hawaii', 'US/Mountain', 'US/Pacific', 'UTC']
tz = pytz.timezone('America/New_York')
tz
?
1
<DstTzInfo 'America/New_York' LMT-1 day, 19:04:00 STD>

pandas中的方法既可以接受时区也可以接受这些对象。

13、时区本地化和转换

　　默认情况下，pandas中的时间序列时单纯的（naive）时区。看看下面这个时间序列：

np.random.seed(100)
rng = pd.date_range('3/9/2012 9:30', periods=6, freq='D')
ts = pd.Series(np.random.randn(len(rng)), index=rng)
print(ts)
?
1
2
3
4
5
6
7
2012-03-09 09:30:00   -1.749765
2012-03-10 09:30:00    0.342680
2012-03-11 09:30:00    1.153036
2012-03-12 09:30:00   -0.252436
2012-03-13 09:30:00    0.981321
2012-03-14 09:30:00    0.514219
Freq: D, dtype: float64

　　

持续更新中......

posted @   小卫哥  阅读(539)  评论(0)  编辑  收藏  举报
编辑推荐：
· 从问题排查到源码分析：ActiveMQ消费端频繁日志刷屏的秘密
· 一次Java后端服务间歇性响应慢的问题排查记录
· dotnet 源代码生成器分析器入门
· ASP.NET Core 模型验证消息的本地化新姿势
· 对象命名为何需要避免'-er'和'-or'后缀
阅读排行：
· “你见过凌晨四点的洛杉矶吗？”--《我们为什么要睡觉》
· 编程神器Trae：当我用上后，才知道自己的创造力被低估了多少
· C# 从零开始使用Layui.Wpf库开发WPF客户端
· C#/.NET/.NET Core技术前沿周刊 | 第 31 期（2025年3.17-3.23）
· 开发的设计和重构，为开发效率服务
点击右上角即可分享
微信分享提示