Question

我有一个不规则索引的时间序列数据，其秒数分辨率如下：

import pandas as pd
idx = ['2012-01-01 12:43:35', '2012-03-12 15:46:43', 
       '2012-09-26 18:35:11', '2012-11-11 2:34:59']
status = [1, 0, 1, 0]
df = pd.DataFrame(status, index=idx, columns = ['status'])
df = df.reindex(pd.to_datetime(df.index))

In [62]: df
Out[62]: 
                     status
2012-01-01 12:43:35       1
2012-03-12 15:46:43       0
2012-09-26 18:35:11       1
2012-11-11 02:34:59       0

我感兴趣的是当年状态为1的年份。我目前的做法是，我在一年中的每一秒重新索引df并使用向前填充，如：

full_idx = pd.date_range(start = '1/1/2012', end = '12/31/2012', freq='s')
df1 = df.reindex(full_idx, method='ffill')

返回一个DataFrame，其中包含该年度的每一秒，然后我可以计算其平均值，以查看1状态中的时间百分比，如：

In [66]: df1
Out[66]: 
<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 31536001 entries, 2012-01-01 00:00:00 to 2012-12-31 00:00:00
Freq: S
Data columns:
status    31490186  non-null values
dtypes: float64(1)


In [67]: df1.status.mean()
Out[67]: 0.31953371123308066

问题在于我必须为大量数据执行此操作，并且在一年中每秒重新编制索引是迄今为止最昂贵的操作。

有什么更好的方法可以做到这一点？

Answer 1

似乎没有一个pandas方法来计算不规则时间序列的条目之间的时间差异，尽管有一种方便的方法可以将时间序列索引转换为datetime.datetime个对象的数组，这可以通过减法转换为datetime.timedelta个对象。

In [6]: start_end = pd.DataFrame({'status': [0, 0]},
                                 index=[pd.datetools.parse('1/1/2012'),
                                        pd.datetools.parse('12/31/2012')])

In [7]: df = df.append(start_end).sort()

In [8]: df
Out[8]: 
                     status
2012-01-01 00:00:00       0
2012-01-01 12:43:35       1
2012-03-12 15:46:43       0
2012-09-26 18:35:11       1
2012-11-11 02:34:59       0
2012-12-31 00:00:00       0

In [9]: pydatetime = pd.Series(df.index.to_pydatetime(), index=df.index)

In [11]: df['duration'] = pydatetime.diff().shift(-1).\
              map(datetime.timedelta.total_seconds, na_action='ignore')

In [16]: df
Out[16]: 
                     status  duration
2012-01-01 00:00:00       0     45815
2012-01-01 12:43:35       1   6145388
2012-03-12 15:46:43       0  17117308
2012-09-26 18:35:11       1   3916788
2012-11-11 02:34:59       0   4310701
2012-12-31 00:00:00       0       NaN

In [17]: (df.status * df.duration).sum() / df.duration.sum()
Out[17]: 0.31906950786402843

注意：

我们的答案似乎有所不同，因为我在第一个时间戳之前将status设置为零，而这些条目在您的df1中为NA，因为前转填充没有起始值，大熊猫排除了NA值意味着（）。
timedelta.total_seconds()是Python 2.7中的新功能。

此方法与重新索引的时间比较：

In [8]: timeit delta_method(df)
1000 loops, best of 3: 1.3 ms per loop

In [9]: timeit redindexing(df)
1 loops, best of 3: 2.78 s per loop

Answer 2

另一种可能的方法是使用traces。

import traces
from dateutil.parser import parse as date_parse

idx = ['2012-01-01 12:43:35', '2012-03-12 15:46:43', 
       '2012-09-26 18:35:11', '2012-11-11 2:34:59']
status = [1, 0, 1, 0]

# create a TimeSeries from date strings and status
ts = traces.TimeSeries(default=0)
for date_string, status_value in zip(idx, status):
    ts[date_parse(date_string)] = status_value

# compute distribution  
ts.distribution(
    start=date_parse('2012-01-01'),
    end=date_parse('2013-01-01'),
)
# {0: 0.6818022667476219, 1: 0.31819773325237805}

该值在2012年1月1日开始和2012年12月31日 end 之间计算（相当于2013年1月1日开始），无需重新采样，并假设状态为{{1在年初（0参数）

计时结果：

default=0

计算特定状态下时间序列数据的时间

2 个答案: