首页 / 知识

Python的time.clock（）与time.time（）的准确性？

2023-04-16 17:18:00

Python's time.clock() vs. time.time() accuracy?

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

例如：

1
2
3

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

1
2
3

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

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

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

time.clock()

On Unix, return the current processor time as a floating point number
expressed in seconds. The precision, and in fact the very definition
of the meaning of"processor time", depends on that of the C function
of the same name, but in any case, this is the function to use for
benchmarking Python or timing algorithms.

On Windows, this function returns wall-clock seconds elapsed since the
first call to this function, as a floating point number, based on the
Win32 function QueryPerformanceCounter(). The resolution is typically
better than one microsecond.

此外，还有用于基准代码段的Timeit模块。

简短的回答是：大多数情况下，time.clock()会更好。但是，如果您正在对一些硬件(例如您在GPU中放入的一些算法)进行计时，那么time.clock()将不再使用这一次，而time.time()是唯一剩下的解决方案。

注：无论采用何种方法，计时都将取决于您无法控制的因素(过程切换的时间、频率等)，time.time()的情况更糟，但time.clock()也存在，因此您不应只运行一次计时测试，而应始终运行一系列测试并查看时间的平均值/方差。

其他人则回答说：time.time()对time.clock()。

但是，如果您正在为基准测试/概要分析的目的对代码块的执行进行计时，那么您应该看看timeit模块。

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

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

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

clock()->浮点数

返回自进程启动以来的CPU时间或实时，或自第一次呼叫clock()。这和系统一样精确。记录。

time()->浮点数

返回当前时间(以秒为单位)。如果系统时钟提供分数秒，则可能存在。

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

取决于你关心什么。如果您指的是墙时间(如墙上时钟上的时间)，那么time.clock()不提供准确度，因为它可以管理CPU时间。

因为我自己的practice. time()比Linux上的clock()有更好的精度。clock()的精度只有10毫秒以下，而time()的精度则很高。我的测试是在CentOS 6.4，python 2.6上

1
2
3
4
5
6
7

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
2
3
4
5
6
7
8

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

不同之处是平台特定的。

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

对于您描述的示例，您可能希望使用"Timeit"模块。

在unix time.clock()中，测量当前进程所使用的CPU时间量，因此从过去的某个时间点测量经过的时间是没有好处的。在Windows上，它将测量自第一次调用函数以来经过的墙时钟秒数。在任何一个系统时间上，time()都将返回从epoch以来经过的秒数。

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

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

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

time()以浮点数形式返回自epoch以来的秒数(以UTC为单位)。不能保证在1秒内获得更好的精度(即使time()返回浮点数)。另外请注意，如果在对该函数的两次调用之间设置了系统时钟，则第二次函数调用将返回一个较低的值。

我用这段代码比较两种方法，我的操作系统是Windows8，处理器核心i5，RAM 4GB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

输出：

时间()=0.0993799996376

时钟()=0.0993572257367

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

正如其他人所指出的，time.clock()不赞成使用time.perf_counter()或time.process_time()，但python 3.7引入了与time.perf_counter_ns()、time.process_time_ns()和time.time_ns()以及3个其他功能一起使用的纳秒分辨率计时。

PEP 564中详细介绍了这6种新的纳秒分辨率函数：

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()

These functions are similar to the version without the _ns suffix, but
return a number of nanoseconds as a Python int.

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

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

但是如果subject是time的话，速度会更快些？

一个小测试案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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不存储第一个/最后一个值，不能继续计数。无法合并另一个计数器…

比较UbuntuLinux和Windows7的测试结果。

关于Ubuntu