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

Question

我在python脚本中有以下代码：

def fun(): 
  #Code here
fun()

我想执行这个脚本，并找出在几分钟内执行所需的时间。如何知道执行此脚本需要多少时间？一个例子将不胜感激。

Answer 1

from datetime import datetime
startTime = datetime.now()
#do something
#Python 2: 
print datetime.now() - startTime 
#Python 3: 
print(datetime.now() - startTime)

Answer 2

您是否在 Linux 或 UNIX 上从命令行执行脚本？在这种情况下，您可以使用

time ./script.py

Answer 3

import time
start = time.time()
fun()
# python 2
print 'It took', time.time()-start, 'seconds.'
# python 3
print('It took', time.time()-start, 'seconds.')

Answer 4

我通常做的是使用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 也会提供配置文件库。

Answer 5

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))

Answer 6

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

以前的代码对我有用，没有问题！

Answer 7

使用 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((或任何数字！(，然后将答案除以数字得到平均值。

我希望这有所帮助。

Answer 8

纯Python

更好的是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}")

这家伙也推荐了(5：30(。

文档：

time. perf_counter() → float

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

使用perf_counter_ns()避免了浮子型。

版本 3.3 中的新功能。

在 3.10 版更改： 在 Windows 上，该功能现在是系统范围的。

<小时 />

Jupyter Notebook： %timeit & %time magic

如果您正在使用Jupyter Notebook(例如Google 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)

然后在单独的单元格中，对函数进行多次计时：

%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

您可以在此处找到有关魔术命令的更多信息。

Answer 9

这是我使用函数式编程执行此操作的方式 - 没有全局命名空间污染，复数的正确变形，只使用一个装饰器，所有这些都只有四个导入，与从 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.

Answer 10

使用时间和日期时间包。

如果有人想执行此脚本，并找出在几分钟内执行所需的时间

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))

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

Answer 11

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

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

该函数将执行 1 次(数字 = 1(，并将测量所需的时间。