我在 python 脚本中有以下代码：
def fun():
#Code here
fun()
我想执行这个脚本，并找出执行时间（以分钟为单位）。我如何知道该脚本执行花费了多少时间？一个例子将非常感激。
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
import time
start = time.time()
fun()
# python 2
print 'It took', time.time()-start, 'seconds.'
# python 3
print('It took', time.time()-start, 'seconds.')
我通常做的是使用
clock()time()timeclocktime例如，
def fn():
st = time()
dostuff()
print 'fn took %.2f seconds' % (time() - st)
或者，您也可以使用
timeittimetimeit来自 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。如果您希望脚本运行时间采用易于阅读的格式，无论是秒还是天，您可以转换为
timedeltastrruntime = time() - st
print 'runtime:', timedelta(seconds=runtime)
然后会打印出
[D day[s], ][H]H:MM:SS[.UUUUUU]最后，如果您真正想要的是分析代码，Python 也提供了 profile 库。
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))
import time
startTime = time.time()
# Your code here !
print ('The script took {0} second !'.format(time.time() - startTime))
以前的代码对我来说没有问题！
使用timeit模块。这很容易。运行您的 example.py 文件，使其在 Python Shell 中处于活动状态，您现在应该能够在 shell 中调用您的函数。尝试一下看看是否有效
>>>fun(input)
output
很好，可行，现在导入 timeit 并设置计时器
>>>import timeit
>>>t = timeit.Timer('example.fun(input)','import example')
>>>
现在我们已经设置了计时器，我们可以看到需要多长时间
>>>t.timeit(number=1)
some number here
我们就这样，它会告诉您执行该函数花费了多少秒（或更短）。如果它是一个简单的函数，那么您可以将其增加到 t.timeit(number=1000) （或任何数字！），然后将答案除以数字以获得平均值。
我希望这有帮助。
更好的是
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如果您使用 Jupyter Notebook（例如 Google Colab），则可以使用 IPython Magic Commands。
示例：
import time
import numpy as np
np.random.seed(42)
def fun():
time.sleep(0.1+np.random.rand()*0.05)
然后在一个单独的单元格中，对函数进行计时多次次：
%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
您可以在此处找到有关 Magic Commands 的更多信息。
使用时间和日期时间包。
如果有人想执行这个脚本并找出执行时间（以分钟为单位）
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))
上面的代码对我有用。我希望这有帮助。
这是我使用函数式编程实现此目的的方法 - 没有全局名称空间污染，复数的正确变形，仅使用一个装饰器，全部只包含四个导入，与从 3.6 开始的 Python 版本兼容（如果删除类型提示）。我的所有脚本中都有这个函数：
import re
import time
from functools import wraps
from typing import Callable, ParamSpec, TypeVar
P = ParamSpec("P")
R = TypeVar("R")
def time_function(func: Callable[P, R]) -> Callable[P, R]:
@wraps(func)
def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
"""Time scripts using a decorator - no global namespace pollution, proper
inflection of plurals, only only one decorator call,
all with only four imports."""
starting_time = time.perf_counter()
name = func.__name__
name = "main function" if name == "main" else f'function "{name}"'
print(time.strftime("%H:%M:%S", time.localtime()) + f": Starting {name}...")
result = func(*args, **kwargs)
# Formatting with proper inflection of plurals, using regular expressions
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 ")
print(f"{name} took {runtime} to run.".capitalize())
return result
return wrapper
输入示例：
@time_function
def main() -> None:
time.sleep(15)
if __name__ == '__main__':
main()
输出：
20:58:28: Starting script...
The script took 15 seconds to run.
输入示例：
@time_function
def main() -> None:
time.sleep(61)
if __name__ == '__main__':
main()
输出：
22:47:29: Starting script...
The script took 1 minute and 1 second to run.
适用于 Windows 用户。
如果您想记录执行完整Python文件的时间，请使用下面给出的简单代码。
Measure-Command {python YourScript.py}
导入 timeit 模块并将脚本中您想要计时的部分定义为函数（例如 main()）。
import timeit
BF = timeit.timeit('BruteForce_MemoryEfficiency.main()', setup='import BruteForce_MemoryEfficiency', number=1)
print(BF)
该函数将执行1次（次数=1），并测量所需时间。