Python 的 time.clock() 与 time.time() 准确度如何？-IT科技

摘要：问题描述：在 Python 中，哪个更适合用于计时？time.clock() 还是 time.time()？哪一个更准确？例如：start = time.clock() ... do something elapsed = (time.clock() - start) 对阵start = time.time(...

问题描述：

在 Python 中，哪个更适合用于计时？time.clock() 还是 time.time()？哪一个更准确？

例如：

start = time.clock()
... do something
elapsed = (time.clock() - start)

对阵

start = time.time()
... do something
elapsed = (time.time() - start)

解决方案 1：

从 3.3 开始，time.clock()已被弃用，建议改用time.process_time()或time.perf_counter()。

之前在 2.7 版本中，根据时间模块文档：

时间.时钟()
在 Unix 上，以浮点数形式返回当前处理器时间（以秒为单位）。精度（实际上“处理器时间”的含义）取决于同名 C 函数的精度，但无论如何，这是用于对 Python 或计时算法进行基准测试的函数。
在 Windows 上，此函数基于 Win32 函数 QueryPerformanceCounter() 返回自第一次调用此函数以来经过的挂钟秒数（浮点数）。精度通常优于一微秒。

此外，还有用于对代码片段进行基准测试的timeit模块。

解决方案 2：

简短的回答是：大多数情况下time.clock()会更好。但是，如果你正在对某些硬件进行计时（例如，你放入 GPU 中的某些算法），那么time.clock()将消除这个时间，time.time()这是剩下的唯一解决方案。

注意：无论使用何种方法，时间安排都取决于您无法控制的因素（过程何时切换、切换频率如何等），这对于来说更糟糕，time.time()但也存在于中time.clock()，因此您不应该只运行一个时间测试，而应该始终运行一系列测试并查看时间的平均值/方差。

解决方案 3：

其他人已回答有关：time.time()vs. 的问题time.clock()。

但是，如果您为了基准测试/分析目的而对一段代码的执行进行计时，那么您应该查看一下该timeit模块。

解决方案 4：

要记住一件事：更改系统时间会产生影响，time.time()但不会time.clock()。

我需要控制一些自动测试的执行。如果测试用例的某一步骤花费的时间超过给定的时间，则中止该 TC 并继续执行下一步。

但有时需要更改系统时间（以检查被测应用程序的调度程序模块），因此在将系统时间设置为未来几个小时后，TC 超时到期，测试用例被中止。我不得不从切换到time.time()才能time.clock()正确处理这个问题。

解决方案 5：

clock()-> 浮点数

返回自进程启动或第一次调用以来的 CPU 时间或实际时间clock()。其精度与系统记录的精度相同。

time()-> 浮点数

返回自纪元以来的当前时间（以秒为单位）。如果系统时钟提供秒的分数，则可能存在秒的分数。

通常time()更精确，因为操作系统存储进程运行时间的精度不如存储系统时间（即实际时间）

解决方案 6：

取决于你关心什么。如果你指的是挂钟时间（比如挂在墙上的时钟上的时间），time.clock() 不提供准确性，因为它可能管理 CPU 时间。

解决方案 7：

time()精度比clock()Linux 好。clock()只有不到 10 毫秒的精度。而time()给出了完美的精度。我的测试是在 CentOS 6.4，python 2.6 上进行的

using time():

1 requests, response time: 14.1749382019 ms
2 requests, response time: 8.01301002502 ms
3 requests, response time: 8.01491737366 ms
4 requests, response time: 8.41021537781 ms
5 requests, response time: 8.38804244995 ms

using clock():

1 requests, response time: 10.0 ms
2 requests, response time: 0.0 ms 
3 requests, response time: 0.0 ms
4 requests, response time: 10.0 ms
5 requests, response time: 0.0 ms 
6 requests, response time: 0.0 ms
7 requests, response time: 0.0 ms 
8 requests, response time: 0.0 ms

解决方案 8：

正如其他人所指出的time.clock()，不推荐使用，而建议使用 time.perf_counter()或time.process_time()，但是 Python 3.7 引入了纳秒分辨率计时，包括time.perf_counter_ns()、time.process_time_ns()和time.time_ns()，以及其他 3 个函数。

这 6 个新的纳秒分辨率函数在PEP 564中有详细说明：

time.clock_gettime_ns(clock_id)
time.clock_settime_ns(clock_id, time:int)
time.monotonic_ns()
time.perf_counter_ns()
time.process_time_ns()
time.time_ns()
这些函数与没有 _ns 后缀的版本类似，但以 Python int 形式返回纳秒数。

正如其他人所指出的，使用该timeit模块来计时函数和小代码片段。

解决方案 9：

这种差异因平台而异。

例如，clock() 在 Windows 和 Linux 上有很大不同。

对于您所描述的示例，您可能需要“timeit”模块。

解决方案 10：

time.clock()在 Python 3.8 中被删除，因为它具有平台相关的行为：

在Unix上，以秒表示的浮点数返回当前处理器时间。
在Windows上，此函数以浮点数形式返回自第一次调用此函数以来经过的秒数

print(time.clock()); time.sleep(10); print(time.clock())
# Linux  :  0.0382  0.0384   # see Processor Time
# Windows: 26.1224 36.1566   # see Wall-Clock Time

那么应该选择哪个功能呢？

处理器时间：这是特定进程在 CPU 上执行的时间。睡眠、等待 Web 请求或仅执行其他进程的时间不计入此时间。

+ 使用`time.process_time()`

挂钟时间：这指的是“挂在墙上的钟上”已经过了多少时间，即超出实际时间。

+ 使用`time.perf_counter()`


    - `time.time()`还可以测量挂钟时间，但可以重置，这样你就可以回到过去
    - `time.monotonic()`无法重置（单调 = 只能向前移动），但精度低于`time.perf_counter()`

解决方案 11：

我使用此代码比较两种方法。我的操作系统是 Windows 8、处理器核心 i5、RAM 4GB

import time

def t_time():
    start=time.time()
    time.sleep(0.1)
    return (time.time()-start)


def t_clock():
    start=time.clock()
    time.sleep(0.1)
    return (time.clock()-start)




counter_time=0
counter_clock=0

for i in range(1,100):
    counter_time += t_time()

    for i in range(1,100):
        counter_clock += t_clock()

print "time() =",counter_time/100
print "clock() =",counter_clock/100

输出：

time() = 0.0993799996376

clock() = 0.0993572257367

解决方案 12：

在 Unix 上，time.clock() 测量当前进程已使用的 CPU 时间量，因此它不适用于测量从过去某个时间点开始经过的时间。在 Windows 上，它将测量自第一次调用该函数以来经过的挂钟秒数。在任一系统上，time.time() 都将返回自纪元以来经过的秒数。

如果您编写的代码仅适用于 Windows，则两者都可以工作（尽管您将以不同的方式使用它们 - time.clock() 不需要减法）。如果要在 Unix 系统上运行，或者您想要保证可移植的代码，您将需要使用 time.time()。

解决方案 13：

简短回答：在 Python 中使用time.clock()进行计时。

在 *nix 系统上，clock() 返回处理器时间作为浮点数，以秒为单位。在 Windows 上，它返回自第一次调用此函数以来经过的秒数，以浮点数表示。

time() 以浮点数形式返回自 UTC 纪元以来的秒数。无法保证您会获得比 1 秒更好的精度（即使 time() 返回浮点数）。还请注意，如果在两次调用此函数之间已将系统时钟调回，则第二次函数调用将返回较低的值。

解决方案 14：

据我所知，time.clock() 的精度与系统允许的精度一样。

解决方案 15：

正确答案：它们都是相同长度的分数。

但是哪个更快subject呢time？

一个小测试用例：

import timeit
import time

clock_list = []
time_list = []

test1 = """
def test(v=time.clock()):
    s = time.clock() - v
"""

test2 = """
def test(v=time.time()):
    s = time.time() - v
"""
def test_it(Range) :
    for i in range(Range) :
        clk = timeit.timeit(test1, number=10000)
        clock_list.append(clk)
        tml = timeit.timeit(test2, number=10000)
        time_list.append(tml)

test_it(100)

print "Clock Min: %f Max: %f Average: %f" %(min(clock_list), max(clock_list), sum(clock_list)/float(len(clock_list)))
print "Time  Min: %f Max: %f Average: %f" %(min(time_list), max(time_list), sum(time_list)/float(len(time_list)))

我不是在瑞士实验室工作，但我已经测试过了。

基于这个问题：time.clock()比time.time()

编辑：time.clock()是内部计数器，因此不能在外部使用，有限制max 32BIT FLOAT，如果不存储第一个/最后一个值，就无法继续计数。无法合并另一个计数器...

解决方案 16：

比较 Ubuntu Linux 和 Windows 7 的测试结果。

在 Ubuntu 上

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873

在 Windows 7 上

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5