blocks|key|1543922|text|简短的答案是:在大多数情况下，time.clock()会更好。然而，如果你正在计时一些硬件(例如，你放在图形处理器中的一些算法)，那么time.clock()将摆脱这个时间，而time.time()是唯一剩下的解决方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1543923|注意:无论使用哪种方法，计时都将取决于您无法控制的因素(进程何时切换，频率如何...)，这在time.time()中更糟，但在time.clock()中也存在，因此您永远不应该只运行一次计时测试，而是始终运行一系列测试并查看时间的均值/方差。|1543924|entityMap^0|F|C|1V|C|2G|B|0|1A|B|1R|C|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

The short answer is: most of the time <code>time.clock()</code> will be better.
However, if you're timing some hardware (for example some algorithm you put in the GPU), then <code>time.clock()</code> will get rid of this time and <code>time.time()</code> is the only solution left.

Note: whatever the method used, the timing will depend on factors you cannot control (when will the process switch, how often, ...), this is worse with <code>time.time()</code> but exists also with <code>time.clock()</code>, so you should never run one timing test only, but always run a series of test and look at mean/variance of the times.

blocks|key|1758898|text|Others的回答是：time.time()+vs.+time.clock()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1758899|但是，如果出于基准测试/性能分析的目的对代码块的执行进行计时，则应该查看timeit+module。|1758900|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/85451#85511|1|https://docs.python.org/library/timeit.html^0|B|B|R|C|0|6|0|0|10|6|10|D|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

<a href="https://stackoverflow.com/questions/85451#85511">Others</a> have answered re: <code>time.time()</code> vs. <code>time.clock()</code>. 

However, if you're timing the execution of a block of code for benchmarking/profiling purposes, you should take a look at the <a href="https://docs.python.org/library/timeit.html" rel="nofollow noreferrer"><code>timeit</code> module</a>.

blocks|key|1758760|text|clock()+->浮点数|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1758761|返回自进程开始或第一次调用clock()以来的CPU时间或实时时间。这与系统记录的精度一样高。|1758762|time()+->浮点数|1758763|返回当前自纪元起的时间，单位为秒。如果系统时钟提供了分数秒，则可能会出现分数秒。|1758764|通常time()更精确，因为操作系统不会像存储系统时间(即实际时间)那样精确地存储进程运行时间。|1758765|entityMap^0|0|7|0|D|7|0|0|6|0|0|2|6|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|Y|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|O|$]]

<code>clock()</code> -> floating point number

Return the CPU time or real time since the start of the process or since
the first call to <code>clock()</code>. This has as much precision as the system
records.

<code>time()</code> -> floating point number

Return the current time in seconds since the Epoch.
Fractions of a second may be present if the system clock provides them.

Usually <code>time()</code> is more precise, because operating systems do not store the process running time with the precision they store the system time (ie, actual time)

blocks|key|1544240|text|请记住:更改系统时间会影响time.time()，但不会影响time.clock()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1544241|我需要控制一些自动测试的执行。如果测试用例的一个步骤花费的时间超过给定的时间量，则该TC将中止以继续执行下一步。|1544242|但有时需要一个步骤来更改系统时间(以检查被测应用程序的调度程序模块)，因此在未来几个小时设置系统时间后，TC超时到期，测试用例中止。为了正确处理这个问题，我不得不从time.time()切换到time.clock()。|1544243|entityMap^0|D|B|U|C|0|0|2A|B|2O|C|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

One thing to keep in mind:
 Changing the system time affects <code>time.time()</code> but not <code>time.clock()</code>.

I needed to control some automatic tests executions. If one step of the test case took more than a given amount of time, that TC was aborted to go on with the next one.

But sometimes a step needed to change the system time (to check the scheduler module of the application under test), so after setting the system time a few hours in the future, the TC timeout expired and the test case was aborted. I had to switch from <code>time.time()</code> to <code>time.clock()</code> to handle this properly.

blocks|key|1543782|text|这取决于你关心的是什么。如果您指的是墙上的时间(就像在墙上的时钟上的时间一样)，那么time.clock()不能提供准确性，因为它可以管理CPU时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1543783|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Depends on what you care about. If you mean WALL TIME (as in, the time on the clock on your wall), time.clock() provides NO accuracy because it may manage CPU time.

blocks|key|1544333|text|在Linux上，time()比clock()具有更高的精度。clock()的精度仅小于10ms。而time()提供了完美的精度。我的测试是在CentOS+6.4，Python2.6上进行的|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1544334|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|code-block|syntax|javascript|1544335|using+clock():|1544336|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|1544337|entityMap^0|8|6|F|7|U|7|1D|6|0|0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

<code>time()</code> has better precision than <code>clock()</code> on Linux. <code>clock()</code> only has precision less than 10 ms. While <code>time()</code> gives prefect precision.
My test is on CentOS 6.4， python 2.6

<pre><code>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
</code></pre>

<code>using clock():</code>

<pre><code>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
</code></pre>

blocks|key|1544107|text|不同之处在于不同的平台。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544108|例如，Windows上的clock()与Linux上的非常不同。|1544109|对于您描述的这类示例，您可能需要使用"timeit“模块。|1544110|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The difference is very platform-specific.

clock() is very different on Windows than on Linux, for example.

For the sort of examples you describe, you probably want the "timeit" module instead.

blocks|key|1544038|text|在Unix上，time.clock()测量当前进程使用的CPU时间，因此它不适合测量过去某个时间点的运行时间。在Windows上，它将测量自第一次调用该函数以来经过的挂钟秒数。在任一系统上，time.time()都将返回自纪元以来经过的秒数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544039|如果您正在编写只针对Windows的代码，则这两种方法都可以工作(尽管您将以不同的方式使用这两种方法-time.clock()不需要减法)。如果这将在Unix系统上运行，或者您想要保证代码的可移植性，那么您将需要使用time.time()。|1544040|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

On Unix time.clock() measures the amount of CPU time that has been used by the current process, so it's no good for measuring elapsed time from some point in the past. On Windows it will measure wall-clock seconds elapsed since the first call to the function. On either system time.time() will return seconds passed since the epoch. 

If you're writing code that's meant only for Windows, either will work (though you'll use the two differently - no subtraction is necessary for time.clock()). If this is going to run on a Unix system or you want code that is guaranteed to be portable, you will want to use time.time().

blocks|key|1544394|text|我用这段代码比较了两种方法，.My操作系统是Windows8，处理器核心是i5，内存是4+4GB|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544395|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+%2B=+t_time()

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

print+"time()+=",counter_time/100
print+"clock()+=",counter_clock/100|code-block|syntax|javascript|1544396|输出：|1544397|time()+=+0.0993799996376

clock()+=+0.0993572257367|1544398|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I use this code to compare 2 methods .My OS is windows 8 , processor core i5 , RAM 4GB
<pre><code>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 &quot;time() =&quot;,counter_time/100
print &quot;clock() =&quot;,counter_clock/100
</code></pre>
output:
<pre><code>time() = 0.0993799996376

clock() = 0.0993572257367
</code></pre>

blocks|key|1544156|text|据我所知，time.clock()的精度与您的系统所允许的一样高。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544157|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

To the best of my understanding, time.clock() has as much precision as your system will allow it.

Which is better to use for timing in Python? time.clock() or time.time()? Which one provides more accuracy?

for example:

<pre><code>start = time.clock()
... do something
elapsed = (time.clock() - start)
</code></pre>

vs.

<pre><code>start = time.time()
... do something
elapsed = (time.time() - start)
</code></pre>

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

Windows

Python

CentOS

Linux

Unix

在Python中，哪个更适合用于计时？time.clock()还是time.time()？哪一个提供了更多的准确性？例如：start = time.clock()... do somethingelapsed = (time.clock() - start)与start = time.time()... do somethingelapsed = (time.time() - start)

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

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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