Python 的 time.clock() 与 time.time() 的准确性？

Posted 2023-02-22

【中文标题】Python 的 time.clock() 与 time.time() 的准确性？

【英文标题】：Python's time.clock() vs. time.time() accuracy?

【发布时间】：2010-09-10 06:30:08

【问题描述】：

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

例如：

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

对比

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

【问题讨论】：

请注意，从 Python 3.3 开始，the use of time.clock() is deprecated，建议改用perf_counter() 或process_time()。

@CodyPiersall：即使在 Python 2 上，您也应该 use timeit.default_timer() to measure performance (it is assigned to time.time() or time.clock() depending on OS)。

请参阅this comment，了解进程使用的所有内核如何在time.clock 和time.process_time 中求和，但子进程不是。另见this discussion of precision（当然，因系统而异）。

【参考方案1】：

我用这段代码比较了两种方法。我的操作系统是 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

【参考方案2】：

time.clock() 在 Python 3.8 中被删除，因为它有 platform-dependent behavior:

在

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 上主动执行所花费的时间。睡眠、等待网络请求或仅执行其他进程的时间不会对此产生影响。

使用time.process_time()

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

使用time.perf_counter()

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

【参考方案3】：

time() 在 Linux 上比clock() 具有更好的精度。 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

【讨论】：

所以我假设 time() on wine??

【参考方案4】：

正如其他人所指出的那样，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 module 来计时函数和小代码sn-ps。

【参考方案5】：

clock() -> 浮点数

返回自进程启动或自启动以来的 CPU 时间或实时时间 第一次致电clock()。这具有与系统一样高的精度 记录。

time() -> 浮点数

返回自纪元以来的当前时间（以秒为单位）。 如果系统时钟提供，可能会出现几分之一秒。

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

【参考方案6】：

要记住的一点： 更改系统时间会影响time.time()，但不会影响time.clock()。

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

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

【讨论】：

我在找这个。谢谢 :) 即使用户从操作系统更改时间，它也会对我有所帮助。

如何比较这个时间和用户以小时：分钟格式存储的时间？

【参考方案7】：

Others 已回复：time.time() 与 time.clock()。

但是，如果您正在计时执行代码块以用于基准测试/分析目的，您应该查看timeit module。

【讨论】：

+1：timeit.default_timer 分配给 time.time() 或 time.clock()，具体取决于操作系统。在 Python 3.3+ 上，default_timer 在所有平台上都是 time.perf_counter()。

【参考方案8】：

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

注意：无论使用什么方法，时间都将取决于您无法控制的因素（进程何时切换，多久切换一次，...），time.time() 更糟，但time.clock() 也存在，所以您永远不应该只运行一个计时测试，而应该始终运行一系列测试并查看时间的均值/方差。

【讨论】：

还有当通过异步方式请求网络资源时（进程会被阻塞等待），网络时间会被清除掉。

【参考方案9】：

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

但是如果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，如果不存储第一个/最后一个值，则无法继续计数。无法合并另一个计数器...

【参考方案10】：

比较 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

【讨论】：

请阅读其他答案以了解 windows 与 unix/linux 的区别。

【参考方案11】：

从 3.3 开始，time.clock() is deprecated，建议改用 time.process_time() 或 time.perf_counter()。

之前在 2.7 中，根据 time module docs：

time.clock()

在 Unix 上，以浮点数形式返回当前处理器时间 以秒表示。精度，实际上就是定义 “处理器时间”的含义，取决于 C 函数的含义 同名，但无论如何，这是用于 对 Python 或计时算法进行基准测试。

在 Windows 上，此函数返回自挂钟以来经过的秒数 首先调用这个函数，作为一个浮点数，基于 Win32 函数 QueryPerformanceCounter()。分辨率通常为 优于一微秒。

此外，还有用于基准代码 sn-ps 的 timeit 模块。

【讨论】：

“这是用于对 Python 或计时算法进行基准测试的函数。” 根据此处给出的答案，Python 文档似乎并不准确。 time.clock() 并不总是您想要的基准测试。尤其是存在 timeit 模块

@Corey Goldberg：你也是submit a documentation bug？ （他们的意思是“使用 clock() 而不是 time():，但是是的，它很草率）

@smci: Python bug: remove obsolete remark in time.clock() docs

可以阅读here 似乎time.clock() 的行为依赖于平台，而time.process_time() 则不是。这就是 time.clock() 被弃用的原因。

time.process_time 不包括在睡眠中花费的时间，根据我的经验，在尝试对多线程代码或等待 I/O 的代码进行计时时，这可能是一个问题。唯一没有该问题的计时器是time.time，但速度较慢。难道没有其他选择包括睡眠时间吗？

【参考方案12】：

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

【参考方案13】：

差异是非常特定于平台的。

例如，clock() 在 Windows 上与在 Linux 上非常不同。

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

【讨论】：

你能扩展吗，clock 和"very different" 是什么关系？

【参考方案14】：

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

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

【参考方案15】：

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

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

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

【参考方案16】：

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

【讨论】：

没错，我只是在 Linux 服务器上使用了time.clock()，我得到的数字肯定不是秒