找出 Python 脚本完成执行所需的时间

from datetime import datetime
startTime = datetime.now()


#do something


#Python 2:
print datetime.now() - startTime


#Python 3:
print(datetime.now() - startTime)

您在 Linux 或 UNIX 上从命令行执行脚本吗

time ./script.py

我通常使用 time库中的 clock()或 time()。clock测量解释器时间，而 time测量系统时间。另外的注意事项可以在 医生中找到。

比如说,

def fn():
st = time()
dostuff()
print 'fn took %.2f seconds' % (time() - st)

或者，您也可以使用 timeit。我经常使用 time方法，因为我可以快速地敲击它，但是如果您正在计时一段可隔离的代码，timeit就派上用场了。

从 时间到了,

def test():
"Stupid test function"
L = []
for i in range(100):
L.append(i)


if __name__=='__main__':
from timeit import Timer
t = Timer("test()", "from __main__ import test")
print t.timeit()

然后转换成分数，你可以简单地除以60。如果您希望脚本运行时采用易于阅读的格式，无论是秒还是天，您都可以将其转换为 timedelta和 str:

runtime = time() - st
print 'runtime:', timedelta(seconds=runtime)

然后打印出表格 [D day[s], ][H]H:MM:SS[.UUUUUU]的内容，你可以看看表格 时间三角洲医生。

最后，如果您真正想要的是分析代码，Python 也提供了 配置文件库。

import time
start = time.time()


fun()


# python 2
print 'It took', time.time()-start, 'seconds.'


# python 3
print('It took', time.time()-start, 'seconds.')

使用时间模块。很简单。运行 example.py 文件，使其在 Python Shell 中处于活动状态，现在应该能够在 Shell 中调用函数。试试看能不能用

>>>fun(input)
output

很好，可以了，现在导入计时器并设置一个计时器

>>>import timeit
>>>t = timeit.Timer('example.fun(input)','import example')
>>>

现在我们已经设置好了计时器，我们可以看看需要多长时间

>>>t.timeit(number=1)
some number here

好了，它会告诉你执行这个函数需要多少秒(或者更少)。如果它是一个简单的函数，那么可以将它增加到 t.timeit (number = 1000)(或者任何数字!)然后用数字除以答案得到平均值。

希望这个能帮上忙。

import time


startTime = time.time()
# Your code here !
print ('The script took {0} second !'.format(time.time() - startTime))

以前的代码对我来说没有任何问题！

import sys
import timeit


start = timeit.default_timer()


#do some nice things...


stop = timeit.default_timer()
total_time = stop - start


# output running time in a nice format.
mins, secs = divmod(total_time, 60)
hours, mins = divmod(mins, 60)


sys.stdout.write("Total running time: %d:%d:%d.\n" % (hours, mins, secs))

使用 time 和 datetime 软件包。

如果有人想要执行这个脚本，并且还要了解它在几分钟内执行所花费的时间

import time
from time import strftime
from datetime import datetime
from time import gmtime


def start_time_():
#import time
start_time = time.time()
return(start_time)


def end_time_():
#import time
end_time = time.time()
return(end_time)


def Execution_time(start_time_,end_time_):
#import time
#from time import strftime
#from datetime import datetime
#from time import gmtime
return(strftime("%H:%M:%S",gmtime(int('{:.0f}'.format(float(str((end_time-start_time))))))))


start_time = start_time_()
# your code here #
[i for i in range(0,100000000)]
# your code here #
end_time = end_time_()
print("Execution_time is :", Execution_time(start_time,end_time))

上面的代码对我很有用。我希望这能有所帮助。

纯巨蟒

更妙的是 time.perf_counter():

t0 = time.perf_counter()
fun()
t1 = time.perf_counter()
print(t1-t0)


# and if you really want your answer in minutes:
print(f"In minutes: {(t1-t0)/60}")

由 这家伙推荐(五点半)。

文件 :

time.perf_counter()→ float

返回性能计数器的值(以小数秒为单位) , 也就是说，时钟具有最高的可用分辨率来测量一个短路 它确实包括在睡眠期间经过的时间，并且是 返回值的参考点未定义, 因此，只有两个调用的结果之间的差异是有效的。

使用 perf_counter_ns()可以避免 浮动式。

3.3版本新增。

在3.10版本中更改: 在 Windows 上，该功能现在是全系统范围的。

木星笔记本: %timeit & %time魔术

如果您使用的是 Jupiter Notebook (比如 谷歌 Colab) ，则可以使用 IPython Magic Command。

例如:

import time
import numpy as np
np.random.seed(42)


def fun():
time.sleep(0.1+np.random.rand()*0.05)

然后在一个单独的牢房里，为函数 < em > 多次 计时:

%timeit fun()

产出:

10 loops, best of 5: 120 ms per loop

要计算函数的时间，只能使用 一次:

%time fun()

产出:

CPU times: user 0 ns, sys: 621 µs, total: 621 µs
Wall time: 114 ms

你可以找到更多关于魔法命令 给你的信息。

下面是我使用函数式编程的方法——没有全局名称空间污染，复数的正确变形，在脚本的最顶端只有一个函数调用，全部只有三个导入，与3.6开始的 Python 版本兼容。我在所有剧本中都有这个功能:

import atexit
import re
import time




def time_script() -> None:
"""Local namespace to keep starting time as a free variable."""


starting_time = 0.0


@atexit.register
def time_script_enclosed() -> None:
"""Time your scripts easily. Run in the very beginning of the script."""
nonlocal starting_time


if not starting_time:
starting_time = time.perf_counter()
return print(
time.strftime("%H:%M:%S", time.localtime()) + ": Starting script..."
)


# Formatting with proper inflection of plurals
runtime = time.strftime(
"%#H hours, %#M minutes and %#S seconds",
time.gmtime(time.perf_counter() - starting_time),
)


for old, new in (
(r"^0 hours, ", ""),
(r"^1 hours", "1 hour"),
(r"\b0 minutes and ", ""),
(r"\b1 minutes", "1 minute"),
(r"\b1 seconds", "1 second"),
(r"(?: and|,) 0 seconds", ""),
(r"^0 seconds", "less than a second"),
):
runtime = re.sub(old, new, runtime)
# Make the 0-second or 0-minute situation sound more natural
if ("second" in runtime) != ("minute" in runtime):
runtime = runtime.replace(", ", " and ")
return print(f"The script took {runtime} to run.")


time_script_enclosed()

输入样本:

def main() -> None:
time_script()
time.sleep(15)




if __name__ == '__main__':
main()

产出:

20:58:28: Starting script...
The script took 15 seconds to run.

输入样本:

def main() -> None:
time_script()
time.sleep(61)




if __name__ == '__main__':
main()

产出:

22:47:29: Starting script...
The script took 1 minute and 1 second to run.

导入 timeit 模块，并将想要计时的脚本部分定义为函数(例如 main ())。

import timeit
    

BF = timeit.timeit('BruteForce_MemoryEfficiency.main()', setup='import BruteForce_MemoryEfficiency', number=1)
    

print(BF)

这个函数将执行1次(number = 1) ，并测量所需的时间。