如何获得Python程序执行的时间？

我有一个Python的命令行程序，需要一段时间才能完成。 我想知道完成运行的确切时间。

我查看了timeit模块，但它似乎只适用于小代码片段。 我想要整个程序。

Answer 1

Python中最简单的方法是：

 import time start_time = time.time() main() print("--- %s seconds ---" % (time.time() - start_time)) 

这假设你的程序至less要运行十分之一秒。

打印：

 --- 0.764891862869 seconds --- 

Answer 2

我把这个timing.py模块放到我自己的site-packages目录中，只需在我的模块顶部插入import timing ：

 import atexit from time import clock def secondsToStr(t): return "%d:%02d:%02d.%03d" % \ reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = "="*40 def log(s, elapsed=None): print line print secondsToStr(clock()), '-', s if elapsed: print "Elapsed time:", elapsed print line print def endlog(): end = clock() elapsed = end-start log("End Program", secondsToStr(elapsed)) def now(): return secondsToStr(clock()) start = clock() atexit.register(endlog) log("Start Program") 

我也可以从我的程序中调用timing.log ，如果在我要显示的程序中有重要的阶段。 但是，只要包括import timing将打印开始和结束时间，以及总的经过时间。 （原谅我默默无闻的secondsToStr函数，它只是格式浮点数秒为hh：mm：ss.sssforms。）

注意：以上代码的Python 3版本可以在这里或这里find。

Answer 3

在Linux或UNIX中：

 time python yourprogram.py 

在Windows中，请参阅此Stackoverflow讨论： 如何测量在Windows命令行中的命令的执行时间？

Answer 4

 import time start_time = time.clock() main() print time.clock() - start_time, "seconds" 

time.clock()返回处理器时间，这允许我们只计算这个进程使用的时间（无论如何，在Unix上）。 文档中提到“无论如何，这是用于基准testingPython或时序algorithm的函数”

Answer 5

您可以使用python profiler cProfile来测量CPU时间 ，另外还可以在每个函数中花费多less时间以及调用每个函数的次数。 如果您想提高脚本的性能而不知道从哪里开始，这非常有用。 对另一个SO问题的答案是相当不错的。 查看文档也总是很好的。

下面是一个如何使用cProfile从命令行分析脚本的例子：

 $ python -m cProfile euler048.py 1007 function calls in 0.061 CPU seconds Ordered by: standard name ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.061 0.061 <string>:1(<module>) 1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>) 1 0.005 0.005 0.061 0.061 euler048.py:2(<module>) 1 0.000 0.000 0.061 0.061 {execfile} 1 0.002 0.002 0.053 0.053 {map} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects} 1 0.000 0.000 0.000 0.000 {range} 1 0.003 0.003 0.003 0.003 {sum} 

Answer 6

我真的很喜欢Paul McGuire的回答，但我使用Python3。 所以对于那些有兴趣的人来说：这里是他对Python * 3的* nix（我想，在Windows下，应该使用clock（）来代替time（））的答案的修改。

 #python3 import atexit from time import time, strftime, localtime from datetime import timedelta def secondsToStr(elapsed=None): if elapsed is None: return strftime("%Y-%m-%d %H:%M:%S", localtime()) else: return str(timedelta(seconds=elapsed)) def log(s, elapsed=None): line = "="*40 print(line) print(secondsToStr(), '-', s) if elapsed: print("Elapsed time:", elapsed) print(line) print() def endlog(): end = time() elapsed = end-start log("End Program", secondsToStr(elapsed)) start = time() atexit.register(endlog) log("Start Program") 

如果你觉得这很有用，那么你应该把他的答案提高一票，而不是像他做大部分工作那样）。

Answer 7

我喜欢datetime时间模块提供的输出，其中时间增量对象以人类可读的方式显示必要的天，小时，分钟等。

例如：

 from datetime import datetime start_time = datetime.now() # do your work here end_time = datetime.now() print('Duration: {}'.format(end_time - start_time)) 

示例输出，例如

 Duration: 0:00:08.309267 

要么

 Duration: 1 day, 1:51:24.269711 

更新：正如JF塞巴斯蒂安提到的，这种方法可能会遇到一些当地时间的棘手的情况，所以使用更安全：

 import time from datetime import timedelta start_time = time.monotonic() end_time = time.monotonic() print(timedelta(seconds=end_time - start_time)) 

Answer 8

对Linux更好： /usr/bin/time

 $ /usr/bin/time -v python rhtest2.py Command being timed: "python rhtest2.py" User time (seconds): 4.13 System time (seconds): 0.07 Percent of CPU this job got: 91% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 0 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 15 Minor (reclaiming a frame) page faults: 5095 Voluntary context switches: 27 Involuntary context switches: 279 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0 

通常情况下， time就是一个更简单的shell内build函数，它会影响更强大的/usr/bin/time 。

Answer 9

rogeriopvl的解决scheme工作正常，但如果你想要更具体的信息，你可以使用python内置分析器。 检查这个页面：

http://docs.python.org/library/profile.html

一个分析器告诉你很多有用的信息，比如在每个函数中花费的时间

Answer 10

 from time import time start_time = time() ... end_time = time() time_taken = end_time - start_time # time_taken is in seconds hours, rest = divmod(time_taken,3600) minutes, seconds = divmod(rest, 60) 

Answer 11

我查看了timeit模块，但它似乎只适用于小代码片段。 我想要整个程序。

 $ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()" 

它运行your_module.main()函数，并使用time.time()函数作为一个计时器来打印经过的时间。

要在Python中模拟/usr/bin/time ，请参阅使用/ usr / bin / time的Pythonsubprocess：如何捕获计时信息但忽略所有其他输出？ 。

要测量每个函数的CPU时间（例如，不包括time.sleep()时间），可以使用profile模块（Python 2上的cProfile ）：

 $ python3 -mprofile your_module.py 

如果您希望使用与profile模块使用相同的计时器，则可以将-p命令传递给上面的timeit命令。

请参阅如何configurationPython脚本？

Answer 12

Ipython“timeit”任何脚本：

 def foo(): %run bar.py timeit foo() 

Answer 13

time.clock（）

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

time.perf_counter（）

返回性能计数器的值（小数秒），即具有最高可用分辨率的时钟，以测量短时间。 它包括睡眠时间和系统范围内的时间。

time.process_time（）

返回当前进程的系统和用户CPU时间之和的值（小数秒）。 它不包括睡眠时间。

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

Answer 14

下面的代码片段用一个漂亮的可读的<HH:MM:SS>格式打印经过的时间。

 import time from datetime import timedelta start_time = time.time() # # Perform lots of computations. # elapsed_time_secs = time.time() - start_time print "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs)) 

Answer 15

我也很喜欢Paul McGuire的回答，提出了一个适合我更多需求的上下文pipe理器。

 import datetime as dt import timeit class TimingManager(object): """Context Manager used with the statement 'with' to time some execution. Example: with TimingManager() as t: # Code to time """ clock = timeit.default_timer def __enter__(self): """ """ self.start = self.clock() self.log('\n=> Start Timing: {}') return self def __exit__(self, exc_type, exc_val, exc_tb): """ """ self.endlog() return False def log(self, s, elapsed=None): """Log current time and elapsed time if present. :param s: Text to display, use '{}' to format the text with the current time. :param elapsed: Elapsed time to display. Dafault: None, no display. """ print s.format(self._secondsToStr(self.clock())) if(elapsed is not None): print 'Elapsed time: {}\n'.format(elapsed) def endlog(self): """Log time for the end of execution with elapsed time. """ self.log('=> End Timing: {}', self.now()) def now(self): """Return current elapsed time as hh:mm:ss string. :return: String. """ return str(dt.timedelta(seconds = self.clock() - self.start)) def _secondsToStr(self, sec): """Convert timestamp to h:mm:ss string. :param sec: Timestamp. """ return str(dt.datetime.fromtimestamp(sec)) 

Answer 16

有一个timeit模块可以用来计算python代码的执行时间。 它有详细的文档和Python文档中的例子（ https://docs.python.org/2/library/timeit.html ）

Answer 17

这是Paul McGuire的答案对我很有用。 以防万一有人遇到了麻烦。

 import atexit from time import clock def reduce(function, iterable, initializer=None): it = iter(iterable) if initializer is None: value = next(it) else: value = initializer for element in it: value = function(value, element) return value def secondsToStr(t): return "%d:%02d:%02d.%03d" % \ reduce(lambda ll,b : divmod(ll[0],b) + ll[1:], [(t*1000,),1000,60,60]) line = "="*40 def log(s, elapsed=None): print (line) print (secondsToStr(clock()), '-', s) if elapsed: print ("Elapsed time:", elapsed) print (line) def endlog(): end = clock() elapsed = end-start log("End Program", secondsToStr(elapsed)) def now(): return secondsToStr(clock()) def main(): start = clock() atexit.register(endlog) log("Start Program") 

在导入文件后从程序中调用timing.main() 。

Answer 18

要使用metakermit的 python 2.7 更新的答案 ，你将需要单调包。

代码将如下所示：

 from datetime import timedelta from monotonic import monotonic start_time = monotonic() end_time = monotonic() print(timedelta(seconds=end_time - start_time)) 

Answer 19

只需使用timeit模块。 它适用于Python 2和Python 3

 import timeit start = timeit.default_timer() #ALL THE PROGRAM STATEMETNS stop = timeit.default_timer() execution_time = stop - start print("Program Executed in "+execution_time) #It returns time in sec 

它以秒为单位返回，你可以有你的执行时间。 很简单，但是你应该把它们写在启动程序执行的主函数中。 如果你想要得到执行时间，即使你得到错误，然后把你的参数“开始”，并计算在那里

 def sample_function(start,**kwargs): try: #your statements Except: #Except Statements stop = timeit.default_timer() execution_time = stop - start print("Program Executed in "+execution_time) 

Answer 20

Python程序执行度量的时间可能不一致，具体取决于：

• 同一个程序可以用不同的algorithm进行评估
• 运算时间因algorithm而异
• 运行时间因实现而异
• 运行时间因电脑而异
• 运行时间不是基于小input的可预测的

这是因为最有效的方法是使用“增长顺序”，并学习大“O”符号来做到这一点， https://en.wikipedia.org/wiki/Big_O_notation

无论如何，您可以尝试使用这个简单的algorithm， 以每秒特定的计算机步数来评估任何Python程序的性能： 使其适应您要评估的程序

 import time now = time.time() future = now + 10 step = 4 # why 4 steps? because until here already 4 operations executed while time.time() < future: step += 3 # why 3 again? because while loop execute 1 comparison and 1 plus equal statement step += 4 # why 3 more? because 1 comparison starting while when time is over plus final assignment of step + 1 and print statement print(str(int(step / 10)) + " steps per second") 

希望这对你有所帮助。