使用time模块测量运行时间

与时间模块在python是可能测量经过的时间?如果是，我该怎么做?

我需要这样做，以便如果光标在小部件中停留了一段时间，就会发生一个事件。

528209 次浏览
小开
最佳答案 
start_time = time.time()
# your code
elapsed_time = time.time() - start_time

你也可以编写简单的装饰器来简化各种函数执行时间的测量:

import time
from functools import wraps


PROF_DATA = {}


def profile(fn):
@wraps(fn)
def with_profiling(*args, **kwargs):
start_time = time.time()


ret = fn(*args, **kwargs)


elapsed_time = time.time() - start_time


if fn.__name__ not in PROF_DATA:
PROF_DATA[fn.__name__] = [0, []]
PROF_DATA[fn.__name__][0] += 1
PROF_DATA[fn.__name__][1].append(elapsed_time)


return ret


return with_profiling


def print_prof_data():
for fname, data in PROF_DATA.items():
max_time = max(data[1])
avg_time = sum(data[1]) / len(data[1])
print "Function %s called %d times. " % (fname, data[0]),
print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)


def clear_prof_data():
global PROF_DATA
PROF_DATA = {}

用法:

@profile
def your_function(...):
...

您可以同时分析多个函数。然后要打印测量值，只需调用print_prof_data():

小开

time.time()将做这项工作。

import time


start = time.time()
# run your code
end = time.time()


elapsed = end - start

你可能想看这问题，但我不认为这是必要的。

小开

您需要导入时间，然后使用time.time()方法来了解当前时间。

import time


start_time=time.time() #taking current time as starting time


#here your code


elapsed_time=time.time()-start_time #again taking current time - starting time
小开

对于想要更好格式的用户，

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

将打印出来，持续2秒:

'00:00:02'

在7分1秒内:

'00:07:01'

注意，gmtime的最小时间单位是秒。如果您需要微秒，请考虑以下内容:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds)

strftime 文档

小开

为了最好地度量运行时间(自Python 3.3起)，请使用time.perf_counter()。

返回性能计数器的值(以小数秒为单位)，即具有最高可用分辨率的时钟，用于测量短时间。它确实包括睡眠期间所消耗的时间，并且是系统范围的。返回值的参考点未定义，因此只有连续调用结果之间的差值才是有效的。

对于小时/天量级的测量，你不关心亚秒级的分辨率，所以使用time.monotonic()代替。

返回单调时钟的值(以小数秒为单位)，即不能倒退的时钟。时钟不受系统时钟更新的影响。返回值的参考点未定义，因此只有连续调用结果之间的差值才是有效的。

在许多实现中，它们实际上可能是相同的东西。

在3.3之前，你只能使用time.clock()。

在Unix上，返回以秒表示的浮点数形式的当前处理器时间。精度，实际上是“处理器时间”的定义，取决于同名C函数的定义。

在Windows上，该函数根据Win32函数QueryPerformanceCounter()返回自第一次调用该函数以来经过的时钟秒数，作为浮点数。分辨率通常优于1微秒。

Python 3.7更新

Python 3.7新增PEP 564——添加具有纳秒分辨率的新时间函数。

使用这些函数可以进一步消除舍入和浮点错误，特别是在测量非常短的周期时，或者应用程序(或Windows机器)是长时间运行的。

决议开始分解perf_counter()大约100天后。因此，例如，在正常运行一年之后，它可以测量的最短间隔(大于0)将比启动时更大。

Python 3.8的更新

time.clock现在已经没有了。

小开

更长的一段时间。

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

将打印

00:03:15

如果超过24小时

25:33:57

这是受到霍夫斯特回答的启发。谢谢你，罗格尔!

小开

瓦迪姆·申德的反应很棒。你也可以使用一个简单的装饰器，如下所示:

import datetime
def calc_timing(original_function):
def new_function(*args,**kwargs):
start = datetime.datetime.now()
x = original_function(*args,**kwargs)
elapsed = datetime.datetime.now()
print("Elapsed Time = {0}".format(elapsed-start))
return x
return new_function()


@calc_timing
def a_func(*variables):
print("do something big!")
小开

另一个计算时间的好方法是使用与 python结构。

与结构会自动调用< em > __enter__ < / em >和< em > __exit__ < / em >方法，这正是我们为事情计时所需要的。

让我们创建一个计时器类。

from time import time


class Timer():
def __init__(self, message):
self.message = message
def __enter__(self):
self.start = time()
return None  # could return anything, to be used like this: with Timer("Message") as value:
def __exit__(self, type, value, traceback):
elapsed_time = (time() - self.start) * 1000
print(self.message.format(elapsed_time))

然后，你可以像这样使用Timer类:

with Timer("Elapsed time to compute some prime numbers: {}ms"):
primes = []
for x in range(2, 500):
if not any(x % p == 0 for p in primes):
primes.append(x)
print("Primes: {}".format(primes))

结果如下:

质数:[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67， 71、73、79、83、89、97、101、103、107、109、113、127、131、137、139、149、151 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239， 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337， 347、349、353、359、367、373、379、383、389、397、401、409、419、421、431、433 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]

计算一些质数所需的时间:5.01704216003418ms

小开

这是一个更新的Vadim Shender的聪明的代码与表格输出:

import collections
import time
from functools import wraps


PROF_DATA = collections.defaultdict(list)


def profile(fn):
@wraps(fn)
def with_profiling(*args, **kwargs):
start_time = time.time()
ret = fn(*args, **kwargs)
elapsed_time = time.time() - start_time
PROF_DATA[fn.__name__].append(elapsed_time)
return ret
return with_profiling


Metrics = collections.namedtuple("Metrics", "sum_time num_calls min_time max_time avg_time fname")


def print_profile_data():
results = []
for fname, elapsed_times in PROF_DATA.items():
num_calls = len(elapsed_times)
min_time = min(elapsed_times)
max_time = max(elapsed_times)
sum_time = sum(elapsed_times)
avg_time = sum_time / num_calls
metrics = Metrics(sum_time, num_calls, min_time, max_time, avg_time, fname)
results.append(metrics)
total_time = sum([m.sum_time for m in results])
print("\t".join(["Percent", "Sum", "Calls", "Min", "Max", "Mean", "Function"]))
for m in sorted(results, reverse=True):
print("%.1f\t%.3f\t%d\t%.3f\t%.3f\t%.3f\t%s" % (100 * m.sum_time / total_time, m.sum_time, m.num_calls, m.min_time, m.max_time, m.avg_time, m.fname))
print("%.3f Total Time" % total_time)
小开

在编程中，有测量时间的两种主要方法，有不同的结果:

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit

  • 处理器时间:这是这个特定进程在CPU上被积极执行的时间。睡眠、等待web请求或只执行其他进程的时间都不会造成这种情况。

    • 使用time.process_time()
      • 李< / ul > < / >

    • 所:这是指“挂在墙上的时钟”上已经过去了多少时间，即外部实时时间。

      • < p > time.perf_counter()使用

        • time.time()也测量时钟的时间，但可以重置，所以你可以回到过去
        • time.monotonic()不能重置(monotonic =只向前)，但精度比time.perf_counter()低
          • 李< / ul > < / > 李< / ul > < / >

提交答案