使用python中的Time模块可以测量经过的时间吗？如果是这样，我该怎么做？
我需要这样做，以便如果光标已在窗口小部件中持续一定时间，则会发生事件。
答案 0 :(得分：424)
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（）：
答案 1 :(得分：87)
time.time()将完成这项工作。
import time
start = time.time()
# run your code
end = time.time()
elapsed = end - start
您可能需要查看this个问题，但我认为没有必要。
答案 2 :(得分：48)
对于想要更好格式化的用户，
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分钟一秒钟：
'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 documentation
答案 3 :(得分：30)
为了最佳度量经过时间（自Python 3.3起），请使用time.perf_counter()。
返回性能计数器的值（以小数秒为单位），即具有最高可用分辨率的时钟，以测量短持续时间。它确实包括睡眠期间经过的时间，并且是系统范围的。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。
对于小时/天的测量，您不必关心亚秒级分辨率，因此请改用time.monotonic()。
返回单调时钟的值（以小数秒为单位），即不能倒退的时钟。时钟不受系统时钟更新的影响。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。
在许多实现中，这些实际上可能是相同的。
在3.3之前，你仍然坚持使用time.clock()。
在Unix上，将当前处理器时间返回为以秒为单位的浮点数。精确度，实际上是“处理器时间”含义的定义，取决于同名C函数的精度。
在Windows上，此函数返回自第一次调用此函数以来经过的挂钟秒，作为浮点数，基于Win32函数QueryPerformanceCounter（）。分辨率通常优于1微秒。
Python 3.7中的新功能是PEP 564 - 添加具有纳秒分辨率的新时间函数。
使用这些可以进一步消除舍入和浮点错误，特别是如果您测量非常短的时间段，或者您的应用程序（或Windows机器）长时间运行。
大约100天后，解决方案开始在perf_counter()上发生故障。因此，例如在一年的正常运行时间之后，它可以测量的最短间隔（大于0）将比它开始时更大。
答案 4 :(得分：6)
您需要导入时间，然后使用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
答案 5 :(得分：5)
持续较长时间。
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
这是受到Rutger Hofste的回答的启发。谢谢Rutger！
答案 6 :(得分：3)
在编程中，有 2种测量时间的主要方法，其结果不同：
>>> 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() 墙壁时钟时间：这是指“挂在墙上的时钟上”经过的时间，即实时时间。
使用time.perf_counter()
time.time()还可测量挂钟时间，但可以重置，因此您可以返回上一时间time.monotonic()无法重设（单调=只能向前移动），但精度低于time.perf_counter() 答案 7 :(得分：1)
Vadim Shender的反应很棒。您还可以使用以下更简单的装饰器：
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!")
答案 8 :(得分：1)
计时的另一种不错的方法是使用 with python结构。
具有结构会自动调用 __ enter __ 和 __ exit __ 方法我们需要对时间进行计时。
让我们创建一个 Timer 类。
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
答案 9 :(得分：0)
这是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)