更快的datetime.strptime

Question

试图获得 unixtimestamp 千千万万 bytes 对象

使用这个

import datetime 
dt_bytes = b'2019-05-23 09:37:56.362965'
#fmt = '%m/%d/%Y %H:%M:%S.%f'
fmt = '%Y-%m-%d %H:%M:%S.%f'
dt_ts = datetime.datetime.strptime(dt_bytes.decode('utf-8'), fmt)
unix_ts = dt_ts.timestamp()

完美的工作。

In [82]: unix_ts                                                                                                             
Out[82]: 1558604276.362965

但是... decode('utf-8') 是将流量减半（从38ksec到20ksec）。

那么有没有一种方法可以 获得来自于 bytes 输入而不是 str 输入？

_UPDATE:_。

我发现瓶颈是 datetime.datetime.strptime(..)所以我换成了 np.datetime64 (见下文)

__更新2:_。 检查下面接受的答案，以获得不同方法的良好性能基准。

Answer 1

我们首先假设你有ISO格式的字符串，'%Y-%m-%dT%H:%M:%S.%f'，在一个 list (我们也暂时不考虑从字节数组解码)。

from datetime import datetime, timedelta
base, n = datetime(2000, 1, 1, 1, 2, 3, 420001), 1000
datelist = [(base + timedelta(days=i)).isoformat(' ') for i in range(n)]
# datelist
# ['2000-01-01 01:02:03.420001'
# ...
# '2002-09-26 01:02:03.420001']

---

从字符串到日期时间对象

让我们定义一些函数，将字符串解析为 datetime，使用不同的方法。

import re
import numpy as np

def strp_isostr(l):
    return list(map(datetime.fromisoformat, l))

def isostr_to_nparr(l):
    return np.array(l, dtype=np.datetime64)

def split_isostr(l):
    def splitter(s):
        tmp = s.split(' ')
        tmp = tmp[0].split('-') + [tmp[1]]
        tmp = tmp[:3] + tmp[3].split(':')
        tmp = tmp[:5] + tmp[5].split('.')
        return datetime(*map(int, tmp))
    return list(map(splitter, l))

def resplit_isostr(l):
    # return list(map(lambda s: datetime(*map(int, re.split('T|-|\:|\.', s))), l))
    return [datetime(*map(int, re.split('\ |-|\:|\.', s))) for s in l]

def full_stptime(l):
    # return list(map(lambda s: datetime.strptime(s, '%Y-%m-%dT%H:%M:%S.%f'), l))
    return [datetime.strptime(s, '%Y-%m-%d %H:%M:%S.%f') for s in l]

如果我运行 %timeit 在我的机器上的IPython控制台中，我得到的结果是

%timeit strp_isostr(datelist)
98.2 µs ± 766 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit isostr_to_nparr(datelist)
1.49 ms ± 13.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit split_isostr(datelist)
3.02 ms ± 236 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit resplit_isostr(datelist)
3.8 ms ± 256 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit full_stptime(datelist)
16.7 ms ± 780 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

所以我们可以得出这样的结论 内置 datetime.fromisoformat 是目前最快的选择 为1000元素输入。然而，这是假设您想要一个 list 以配合工作。如果你需要一个 np.array 的 datetime64 反正，直接去那个似乎是最好的选择。

---

第三方选择：西索8601

如果你能够安装额外的包。ciso8601 是值得一看的。

import ciso8601
def ciso(l):
    return list(map(ciso8601.parse_datetime, l))

%timeit ciso(datelist)
138 µs ± 1.83 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

---

从datetime对象转换为自纪元以来的秒数。

从以下方面来看转换 datetime 对象到POSIX时间戳，使用最明显的 datetime.timestamp 方法似乎是最有效的。

import time
def dt_ts(l):
    return list(map(datetime.timestamp, l))

def timetup(l):
    return list(map(time.mktime, map(datetime.timetuple, l)))

%timeit dt_ts(strp_isostr(datelist))
572 µs ± 4.57 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit timetup(strp_isostr(datelist))
1.44 ms ± 15.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Answer 2

我正在转移到 numpy.datetime64 因为它的延迟比 datetime.strptime

import numpy as np

# This is the format np.datetime64 needs:
#np.datetime64('2002-06-28T01:00:00.000000000+0100')

dt_bytes = b'2019-05-23 09:37:56.362965'
#dt_bytes_for_np = dt_bytes.split(b' ')[0] + b'T' + dt_bytes.split(b' ')[1]
dt_bytes_for_np = dt_bytes.replace(b' ', b'T')
ts = np.datetime64(dt_bytes_for_np)

并获得unixtimestamp（这增加了一点延迟，但仍比不上 datetime.strptime:

ts.astype('datetime64[ns]').astype('float') / 1000000000
1558604276.362965