Python中的高精度时钟

Question

在Python中有没有一种高精度测量时间的方法-比一秒更精确？我怀疑有没有跨平台的方法；我对Unix上的高精度时间很感兴趣，尤其是在Sun SPARC机器上运行的Solaris。

timeit似乎能够高精度地测量时间，但是我不想测量一个代码片段需要多长时间，而是想直接访问时间值。

Answer 1

标准time.time()函数提供亚秒级精度，但该精度因平台而异。对于Linux和Mac，精度是+- 1微秒或0.001毫秒。由于进程中断导致的时钟实现问题，Windows上的Python使用+- 16毫秒精度。如果您正在测量执行时间，timeit模块可以提供更高的分辨率。

>>> import time
>>> time.time()        #return seconds from epoch
1261367718.971009      

Python3.7向time模块引入了新函数，这些函数可以提供更高的分辨率：

>>> import time
>>> time.time_ns()
1530228533161016309
>>> time.time_ns() / (10 ** 9) # convert to floating-point seconds
1530228544.0792289

Answer 2

Python尽量使用平台上最精确的时间函数来实现time.time()：

/* Implement floattime() for various platforms */

static double
floattime(void)
{
    /* There are three ways to get the time:
      (1) gettimeofday() -- resolution in microseconds
      (2) ftime() -- resolution in milliseconds
      (3) time() -- resolution in seconds
      In all cases the return value is a float in seconds.
      Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may
      fail, so we fall back on ftime() or time().
      Note: clock resolution does not imply clock accuracy! */
#ifdef HAVE_GETTIMEOFDAY
    {
        struct timeval t;
#ifdef GETTIMEOFDAY_NO_TZ
        if (gettimeofday(&t) == 0)
            return (double)t.tv_sec + t.tv_usec*0.000001;
#else /* !GETTIMEOFDAY_NO_TZ */
        if (gettimeofday(&t, (struct timezone *)NULL) == 0)
            return (double)t.tv_sec + t.tv_usec*0.000001;
#endif /* !GETTIMEOFDAY_NO_TZ */
    }

#endif /* !HAVE_GETTIMEOFDAY */
    {
#if defined(HAVE_FTIME)
        struct timeb t;
        ftime(&t);
        return (double)t.time + (double)t.millitm * (double)0.001;
#else /* !HAVE_FTIME */
        time_t secs;
        time(&secs);
        return (double)secs;
#endif /* !HAVE_FTIME */
    }
}

(来自http://svn.python.org/view/python/trunk/Modules/timemodule.c?revision=81756&view=markup )

Answer 3

David的帖子试图显示Windows的时钟分辨率是多少。我被他的输出搞糊涂了，所以我写了一些代码，显示我的Windows8 x64笔记本电脑上的time.time()的分辨率为1毫秒：

# measure the smallest time delta by spinning until the time changes
def measure():
    t0 = time.time()
    t1 = t0
    while t1 == t0:
        t1 = time.time()
    return (t0, t1, t1-t0)

samples = [measure() for i in range(10)]

for s in samples:
    print s

以下哪项输出：

(1390455900.085, 1390455900.086, 0.0009999275207519531)
(1390455900.086, 1390455900.087, 0.0009999275207519531)
(1390455900.087, 1390455900.088, 0.0010001659393310547)
(1390455900.088, 1390455900.089, 0.0009999275207519531)
(1390455900.089, 1390455900.09, 0.0009999275207519531)
(1390455900.09, 1390455900.091, 0.0010001659393310547)
(1390455900.091, 1390455900.092, 0.0009999275207519531)
(1390455900.092, 1390455900.093, 0.0009999275207519531)
(1390455900.093, 1390455900.094, 0.0010001659393310547)
(1390455900.094, 1390455900.095, 0.0009999275207519531)

以及一种对增量进行1000个样本平均值的方法：

reduce( lambda a,b:a+b, [measure()[2] for i in range(1000)], 0.0) / 1000.0

它在两个连续的运行中输出：

0.001
0.0010009999275207519

因此，我的Windows8 x64上的time.time()分辨率为1毫秒。

在time.clock()上运行类似的命令会返回0.4微秒的分辨率：

def measure_clock():
    t0 = time.clock()
    t1 = time.clock()
    while t1 == t0:
        t1 = time.clock()
    return (t0, t1, t1-t0)

reduce( lambda a,b:a+b, [measure_clock()[2] for i in range(1000000)] )/1000000.0

返回：

4.3571334791658954e-07

这就是~0.4e-06

关于time.clock()的一个有趣的事情是，它返回方法第一次被调用以来的时间，所以如果你想要微秒级的解析时间，你可以这样做：

class HighPrecisionWallTime():
    def __init__(self,):
        self._wall_time_0 = time.time()
        self._clock_0 = time.clock()

    def sample(self,):
        dc = time.clock()-self._clock_0
        return self._wall_time_0 + dc

(这可能会在一段时间后漂移，但你可以偶尔纠正它，例如dc > 3600会每小时纠正一次)