测量Python中的时间？

我想要的是开始在我的代码中的某处计算时间，然后获取传递的时间，以测量执行less量函数所花费的时间。 我想我使用timeit模块是错误的，但是文档只是让我感到困惑。

import timeit start = timeit.timeit() print "hello" end = timeit.timeit() print end - start 

Answer 1

如果你只是想测量两点之间经过的挂钟时间，你可以使用time.time() ：

 import time start = time.time() print("hello") end = time.time() print(end - start) 

这给出了几秒钟内的执行时间。

自3.3以来的另一种select可能是使用perf_counter或process_time ，这取决于您的要求。 在3.3之前，build议使用使用时间。 time.clock （谢谢@琥珀）。 但是，现在已经废弃了：

在Unix上，将当前处理器时间作为以秒为单位的浮点数返回。 精确度，实际上“处理器时间”含义的定义，取决于同名C函数的定义。

在Windows上，基于Win32函数QueryPerformanceCounter() ，此函数返回自本函数第一次调用以来的挂钟时间（作为浮点数QueryPerformanceCounter() 。 分辨率通常比一微秒更好。

自3.3版弃用 ：此function的行为取决于平台：根据您的要求， 使用perf_counter()或process_time()来取代定义良好的行为。

Answer 2

使用timeit.default_timer而不是timeit.timeit 。 前者自动提供您的平台和Python版本上的最佳时钟：

 from timeit import default_timer as timer start = timer() # ... end = timer() print(end - start) 

timeit.default_timer分配给time.time（）或time.clock（），具体取决于操作系统。 在所有平台上，Python 3.3+ default_timer都是time.perf_counter（） 。 请参阅Python – time.clock（）与time.time（） – 精度？

也可以看看：

• 优化代码
• 如何优化速度

Answer 3

鉴于你想要的function，

test.py：

 def foo(): # print "hello" return "hello" 

使用timeit最简单的方法是从命令行调用它：

 % python -mtimeit -s'import test' 'test.foo()' 1000000 loops, best of 3: 0.254 usec per loop 

不要尝试使用time.time或time.clock （天真）来比较函数的速度。 他们可以给误导性的结果 。

PS。 不要把打印语句放在你想要的function中; 否则测量的时间将取决于terminal的速度 。

Answer 4

仅限Python 3：

由于从Python 3.3开始 ，time.clock（） 不推荐使用 ，所以您需要将time.perf_counter()用于全系统计时，或者将time.perf_counter() time.process_time()用于进程范围的计时，就像您以前使用time.clock() ：

 import time t = time.process_time() #do some stuff elapsed_time = time.process_time() - t 

新的函数process_time将不包括睡眠时间。

Answer 5

使用上下文pipe理器来实现这一点非常有趣，该上下文pipe理器可以自动记住进入到块的开始时间，然后冻结块退出的结束时间。 有一点小小的诡计，你甚至可以从同一个上下文pipe理器函数中获得一个正在运行的经过时间。

核心库没有这个（但可能应该）。 一旦到位，您可以执行以下操作：

 with elapsed_timer() as elapsed: # some lengthy code print( "midpoint at %.2f seconds" % elapsed() ) # time so far # other lengthy code print( "all done at %.2f seconds" % elapsed() ) 

这里的上下文pipe理代码足以做到这一点：

 from contextlib import contextmanager from timeit import default_timer @contextmanager def elapsed_timer(): start = default_timer() elapser = lambda: default_timer() - start yield lambda: elapser() end = default_timer() elapser = lambda: end-start 

还有一些可运行的演示代码：

 import time with elapsed_timer() as elapsed: time.sleep(1) print(elapsed()) time.sleep(2) print(elapsed()) time.sleep(3) 

请注意，通过这个函数的devise， elapsed()的返回值在块退出时被冻结，并且进一步的调用返回相同的持续时间（在这个玩具的例子中大约6秒）。

Answer 6

使用time.time来衡量执行情况，可以让您了解命令的总体执行时间，包括计算机上其他进程所花费的运行时间。 这是用户注意到的时间，但如果你想比较不同的代码片段/algorithm/function/不好

有关timeit更多信息：

• 使用timeit模块
• timeit – 执行一小段Python代码的时间

如果你想更深入的分析剖析：

• http://wiki.python.org/moin/PythonSpeed/PerformanceTips#Profiling_Code
• 你怎么能剖析一个python脚本？

更新 ：在去年我使用了http://pythonhosted.org/line_profiler/ ，发现它非常有帮助，build议使用它而不是Pythons profile模块。

Answer 7

python cProfile和pstats模块为测量某些函数所耗用的时间提供了很好的支持，而无需在现有函数中添加任何代码。

例如，如果你有一个Python脚本timeFunctions.py：

 import time def hello(): print "Hello :)" time.sleep(0.1) def thankyou(): print "Thank you!" time.sleep(0.05) for idx in range(10): hello() for idx in range(100): thankyou() 

要运行分析器并为文件生成统计信息，可以运行：

 python -m cProfile -o timeStats.profile timeFunctions.py 

这样做是使用cProfile模块来分析timeFunctions.py中的所有函数，并收集timeStats.profile文件中的统计信息。 请注意，我们不必将任何代码添加到现有模块（timeFunctions.py），并且可以使用任何模块完成。

一旦你有统计文件，你可以运行pstats模块，如下所示：

 python -m pstats timeStats.profile 

这运行交互式统计浏览器，它给你很多很好的function。 对于你的特定用例，你可以检查你的函数的统计信息。 在我们的例子中，检查两个函数的统计数据显示了以下内容：

 Welcome to the profile statistics browser. timeStats.profile% stats hello <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'hello'> ncalls tottime percall cumtime percall filename:lineno(function) 10 0.000 0.000 1.001 0.100 timeFunctions.py:3(hello) timeStats.profile% stats thankyou <timestamp> timeStats.profile 224 function calls in 6.014 seconds Random listing order was used List reduced from 6 to 1 due to restriction <'thankyou'> ncalls tottime percall cumtime percall filename:lineno(function) 100 0.002 0.000 5.012 0.050 timeFunctions.py:7(thankyou) 

这个虚拟的例子并没有太大的作用，但是给了你一个可以做什么的概念。 关于这种方法的最好的部分是，我不必编辑任何我现有的代码来获得这些数字，显然帮助分析。

Answer 8

我更喜欢这个。 Timeit文档太混乱了。

 from datetime import datetime startTime= datetime.now() # INSERT YOUR CODE timeElapsed=datetime.now()-startTime print('Time elpased (hh:mm:ss.ms) {}'.format(timeElapsed)) 

请注意，这里没有任何格式化，我只是把hh：mm：ss写到打印输出中，以便能够解释timeElapsed

Answer 9

这是一个返回“hh：mm：ss”string的小计时器类：

 class Timer: def __init__(self): self.start = time.time() def restart(self): self.start = time.time() def get_time_hhmmss(self): end = time.time() m, s = divmod(end - self.start, 60) h, m = divmod(m, 60) time_str = "%02d:%02d:%02d" % (h, m, s) return time_str 

用法：

 # Start timer my_timer = Timer() # ... do something # Get time string: time_hhmmss = my_timer.get_time_hhmmss() print("Time elapsed: %s" % time_hhmmss ) # ... use the timer again my_timer.restart() # ... do something # Get time: time_hhmmss = my_timer.get_time_hhmmss() # ... etc 

Answer 10

这里是另一个时间代码的上下文pipe理器 –

用法：

 from benchmark import benchmark with benchmark("Test 1+1"): 1+1 => Test 1+1 : 1.41e-06 seconds 

或者，如果您需要时间值

 with benchmark("Test 1+1") as b: 1+1 print(b.time) => Test 1+1 : 7.05e-07 seconds 7.05233786763e-07 

benchmark.py ：

 from timeit import default_timer as timer class benchmark(object): def __init__(self, msg, fmt="%0.3g"): self.msg = msg self.fmt = fmt def __enter__(self): self.start = timer() return self def __exit__(self, *args): t = timer() - self.start print(("%s : " + self.fmt + " seconds") % (self.msg, t)) self.time = t 

改编自http://dabeaz.blogspot.fr/2010/02/context-manager-for-timing-benchmarks.html

Answer 11

（仅限Ipython）可以使用％timeit来测量平均处理时间：

 def foo(): print "hello" 

接着：

 %timeit foo() 

结果是这样的：

 10000 loops, best of 3: 27 µs per loop 

Answer 12

在python3上：

 from time import sleep, perf_counter as pc t0 = pc() sleep(1) print(pc()-t0) 

优雅和短。

Answer 13

一个超级稍后的反应，但也许它为某人的目的。 这是一个做我认为是超级干净的方法。

 import time def timed(fun, *args): s = time.time() r = fun(*args) print('{} execution took {} seconds.'.format(fun.__name__, time.time()-s)) return(r) timed(print, "Hello") 

请记住，“print”是Python 3中的一个函数，而不是Python 2.7。 但是，它可以与其他function一起使用。 干杯!

Answer 14

我为此做了一个库，如果你想测量一个函数，你可以这样做

 from pythonbenchmark import compare, measure import time a,b,c,d,e = 10,10,10,10,10 something = [a,b,c,d,e] @measure def myFunction(something): time.sleep(0.4) @measure def myOptimizedFunction(something): time.sleep(0.2) myFunction(input) myOptimizedFunction(input) 

https://github.com/Karlheinzniebuhr/pythonbenchmark

Answer 15

还有一种使用timeit的方法 ：

 from timeit import timeit def func(): return 1 + 1 time = timeit(func, number=1) print(time) 

Answer 16

我们也可以将时间转换为人类可读的时间。

 import time, datetime start = time.clock() def num_multi1(max): result = 0 for num in range(0, 1000): if (num % 3 == 0 or num % 5 == 0): result += num print "Sum is %d " % result num_multi1(1000) end = time.clock() value = end - start timestamp = datetime.datetime.fromtimestamp(value) print timestamp.strftime('%Y-%m-%d %H:%M:%S') 

Answer 17

使用分析器模块。 它提供了非常详细的configuration文件。

 import profile profile.run('main()') 

它输出如下所示的内容

  5 function calls in 0.047 seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.000 0.000 :0(exec) 1 0.047 0.047 0.047 0.047 :0(setprofile) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 0 0.000 0.000 profile:0(profiler) 1 0.000 0.000 0.047 0.047 profile:0(main()) 1 0.000 0.000 0.000 0.000 two_sum.py:2(twoSum) 

我发现它非常丰富。

Answer 18

你可以使用timeit。

这里是一个关于如何使用Python REPL来testing带参数的naive_func的例子：

 >>> import timeit >>> def naive_func(x): ... a = 0 ... for i in range(a): ... a += i ... return a >>> def wrapper(func, *args, **kwargs): ... def wrapper(): ... return func(*args, **kwargs) ... return wrapper >>> wrapped = wrapper(naive_func, 1_000) >>> timeit.timeit(wrapped, number=1_000_000) 0.4458435332577161 

如果函数没有任何参数，则不需要包装函数。