Question

哪个更适合用于Python中的计时？ time.clock（）或time.time（）？哪一个提供更准确？

例如：

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

VS

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

Answer 1

从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（）。通常是分辨率   好于一微秒。

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

Answer 2

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

注意：无论使用何种方法，时间都取决于您无法控制的因素（进程何时切换，频率如何......），time.time()情况更糟，但{{1}也存在所以你永远不应该只进行一次计时测试，而是要经常进行一系列的测试，然后看看时间的均值/方差。

Answer 3

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

但是，如果您为执行基准测试/分析目的而执行一段代码，则应该查看timeit module。

Answer 4

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

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

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

Answer 5

clock() - ＆gt;浮点数

返回自进程开始或之后的CPU时间或实时第一次拨打clock()。这与系统一样精确记录。

time() - ＆gt;浮点数

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

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

Answer 6

取决于你关心的事情。如果你的意思是WALL TIME（就像你墙上的时钟一样），time.clock（）提供NO准确性，因为它可以管理CPU时间。

Answer 7

对于我自己的practice. 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

Answer 8

区别在于特定于平台。

例如，

clock（）在Windows上与在Linux上非常不同。

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

Answer 9

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

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

Answer 10

据我所知，time.clock（）具有系统允许的精确度。

Answer 11

正如其他人所指出的那样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()

这些函数类似于没有_ns后缀的版本，但是   以Python int返回一些纳秒数。

正如其他人也注意到的那样，使用timeit module来计算时间函数和小代码片段。

Answer 12

我使用此代码比较2种方法。我的操作系统是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

输出：

时间（）= 0.0993799996376

clock（）= 0.0993572257367

Answer 13

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

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

time（）以UTC为单位返回自纪元以来的秒数，作为浮点数。无法保证您在1秒内获得更好的精度（即使time（）返回浮点数）。另请注意，如果在两次调用此函数之间设置了系统时钟，则第二次函数调用将返回较低的值。

Answer 14

正确答案：它们的长度相同。

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

Answer 15

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上有效执行所花费的时间。睡眠，等待Web请求或仅执行其他进程的时间都不会造成这种情况。
- 使用time.process_time()
墙壁时钟时间：这是指“挂在墙上的时钟上”经过的时间，即实时时间。
- 使用time.perf_counter()
  - time.time()还可测量挂钟时间，但可以重置，因此您可以返回上一时间
  - time.monotonic()无法重设（单调=只能向前移动），但精度低于time.perf_counter()

Answer 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

Answer 17

首选使用time.time（）。

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

17 个答案: