我想要的是在我的代码中的某个地方开始计算时间,然后获得通过的时间,以测量执行少量功能所花费的时间。我认为我使用的是timeit模块错误,但文档只会让我感到困惑。
import timeit
start = timeit.timeit()
print "hello"
end = timeit.timeit()
print end - start
答案 0 :(得分:1112)
如果您只想测量两点之间经过的挂钟时间,可以使用time.time()
:
import time
start = time.time()
print("hello")
end = time.time()
print(end - start)
这以秒为单位给出了执行时间。
自3.3以来的另一个选择可能是使用perf_counter
或process_time
,具体取决于您的要求。在3.3之前,建议使用time.clock
(感谢Amber)。但是,它目前已被弃用:
在Unix上,将当前处理器时间作为浮点数返回 用秒表示。精度,实际上是非常的定义 “处理器时间”的含义取决于C函数的含义 同名。
在Windows上,此函数返回自...以来经过的挂号秒 首先调用此函数,作为浮点数,基于 Win32函数
QueryPerformanceCounter()
。通常是分辨率 好于一微秒。从版本3.3开始不推荐使用:此功能的行为取决于 在平台上:使用
perf_counter()
或process_time()
代替, 根据您的要求,有明确的行为。
答案 1 :(得分:473)
使用timeit.default_timer
代替timeit.timeit
。前者提供了您平台上可用的最佳时钟和自动版本的Python:
from timeit import default_timer as timer
start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282
timeit.default_timer根据操作系统分配给time.time()或time.clock()。在所有平台上,Python 3.3+ default_timer为time.perf_counter()。见Python - time.clock() vs. time.time() - accuracy?
另见:
答案 2 :(得分:107)
从time.clock()is deprecated as of Python 3.3开始,您将需要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
不包括睡眠时间。
答案 3 :(得分:76)
鉴于你想要的时间,
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
(天真)来比较功能的速度。 They can give misleading results
PS。不要将打印语句放在您想要的时间函数中;否则测量的时间将取决于speed of the terminal。
答案 4 :(得分:53)
使用上下文管理器执行此操作很有趣,该上下文管理器会在进入with
块时自动记住开始时间,然后在块退出时冻结结束时间。通过一些小技巧,您甚至可以从相同的上下文管理器功能获得块内运行的经过时间计数。
核心库没有这个(但可能应该)。一旦到位,您可以执行以下操作:
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() )
这里的contextmanager代码足以完成这个诀窍:
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)
注意,通过设计此函数,elapsed()
的返回值在块退出时被冻结,并且其他调用返回相同的持续时间(在此玩具示例中约为6秒)。
答案 5 :(得分:47)
我更喜欢这个。 timeit
doc太令人困惑了。
from datetime import datetime
start_time = datetime.now()
# INSERT YOUR CODE
time_elapsed = datetime.now() - start_time
print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))
请注意,此处没有格式化,我只是在打印输出中写了hh:mm:ss
,因此可以解释time_elapsed
答案 6 :(得分:25)
使用time.time
来衡量执行情况,可以获得命令的总执行时间,包括计算机上其他进程所花费的运行时间。这是用户注意到的时间,但如果您想比较不同的代码片段/算法/函数/ ...则不好...
有关timeit
的更多信息:
如果您想更深入地了解分析:
更新:我在去年使用了http://pythonhosted.org/line_profiler/并发现它非常有帮助,并建议使用它而不是Pythons配置文件模块。
答案 7 :(得分:18)
这是一个微小的计时器类,它返回“hh:mm:ss”字符串:
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
答案 8 :(得分:17)
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),这可以通过任何模块完成。
获得stats文件后,您可以按如下方式运行pstats模块:
python -m pstats timeStats.profile
这将运行交互式统计浏览器,为您提供许多不错的功能。对于您的特定用例,您只需检查您的功能的统计数据。在我们的示例中,检查两个函数的统计信息向我们显示以下内容:
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)
虚拟示例并没有做太多,但让您了解可以做些什么。关于这种方法最好的部分是我不必编辑任何现有代码来获取这些数字,显然有助于分析。
答案 9 :(得分:16)
这是定时代码的另一个上下文管理器 -
用法:
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
答案 10 :(得分:15)
使用探查器模块。它提供了非常详细的资料。
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)
我发现它非常有用。
答案 11 :(得分:12)
(仅限Ipython)您可以使用%timeit来衡量平均处理时间:
def foo():
print "hello"
然后:
%timeit foo()
结果如下:
10000 loops, best of 3: 27 µs per loop
答案 12 :(得分:11)
:
from time import sleep, perf_counter as pc
t0 = pc()
sleep(1)
print(pc()-t0)
优雅而短暂。
答案 13 :(得分:9)
在这里经过许多好的回答以及其他几篇文章之后,这是我的发现。
首先,由于
,您始终要使用timeit
而不是time.time
(在许多情况下是perf计数器API)。
timeit
选择适用于您的OS和Python版本的最佳计时器。 timeit
禁用垃圾收集,但这不是您可能想要或不想要的东西。现在的问题是,timetime并不是那么简单易用,因为它需要设置,并且当您进行大量导入时,事情变得很丑陋。理想情况下,您只需要装饰器或使用with
块并测量时间。不幸的是,没有可用的内置功能,因此我在小实用程序模块下面创建了该程序。
计时实用程序模块
# utils.py
from functools import wraps
import gc
import timeit
def MeasureTime(f):
@wraps(f)
def _wrapper(*args, **kwargs):
gcold = gc.isenabled()
gc.disable()
start_time = timeit.default_timer()
try:
result = f(*args, **kwargs)
finally:
elapsed = timeit.default_timer() - start_time
if gcold:
gc.enable()
print('Function "{}": {}s'.format(f.__name__, elapsed))
return result
return _wrapper
class MeasureBlockTime:
def __init__(self,name="(block)", no_print = False, disable_gc = True):
self.name = name
self.no_print = no_print
self.disable_gc = disable_gc
def __enter__(self):
if self.disable_gc:
self.gcold = gc.isenabled()
gc.disable()
self.start_time = timeit.default_timer()
def __exit__(self,ty,val,tb):
self.elapsed = timeit.default_timer() - self.start_time
if self.disable_gc and self.gcold:
gc.enable()
if not self.no_print:
print('Function "{}": {}s'.format(self.name, self.elapsed))
return False #re-raise any exceptions
如何计时功能
现在,您只需在其前面放置装饰器即可计时任何功能:
import utils
@utils.MeasureTime
def MyBigFunc():
#do something time consuming
for i in range(10000):
print(i)
如何计时代码块
如果要计时部分代码,只需将其放在with
块中:
import utils
#somewhere in my code
with utils.MeasureBlockTime("MyBlock"):
#do something time consuming
for i in range(10000):
print(i)
# rest of my code
优势
有一些半支持版本,所以我想指出一些重点:
with utils.MeasureBlockTime() as t
,然后使用t.elapsed
)。答案 14 :(得分:9)
计算手术持续时间的最简单方法:
import time
start_time = time.monotonic()
print(time.ctime())
<operations, programs>
print('minutes: ',(time.monotonic() - start_time)/60)
答案 15 :(得分:9)
有点超级以后的回应,但也许这对某人有用。这是一种我认为非常干净的方法。
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。但是,它适用于任何其他功能。干杯!
答案 16 :(得分:7)
使用timeit的另一种方法:
from timeit import timeit
def func():
return 1 + 1
time = timeit(func, number=1)
print(time)
答案 17 :(得分:7)
我们还可以将时间转换为人类可读的时间。
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')
答案 18 :(得分:6)
这是一个非常有据可查的,完全类型化的提示修饰符,我用作通用工具:
from functools import wraps
from time import perf_counter
from typing import Any, Callable, Optional, TypeVar, cast
F = TypeVar("F", bound=Callable[..., Any])
def timer(prefix: Optional[str] = None, precision: int = 6) -> Callable[[F], F]:
"""Use as a decorator to time the execution of any function.
Args:
prefix: String to print before the time taken.
Default is the name of the function.
precision: How many decimals to include in the seconds value.
Examples:
>>> @timer()
... def foo(x):
... return x
>>> foo(123)
foo: 0.000...s
123
>>> @timer("Time taken: ", 2)
... def foo(x):
... return x
>>> foo(123)
Time taken: 0.00s
123
"""
def decorator(func: F) -> F:
@wraps(func)
def wrapper(*args: Any, **kwargs: Any) -> Any:
nonlocal prefix
prefix = prefix if prefix is not None else f"{func.__name__}: "
start = perf_counter()
result = func(*args, **kwargs)
end = perf_counter()
print(f"{prefix}{end - start:.{precision}f}s")
return result
return cast(F, wrapper)
return decorator
用法示例:
from timer import timer
@timer(precision=9)
def takes_long(x: int) -> bool:
return x in (i for i in range(x + 1))
result = takes_long(10**8)
print(result)
输出:
takes_long: 4.942629056s True
可以使用以下方法检查doctest:
$ python3 -m doctest --verbose -o=ELLIPSIS timer.py
类型提示:
$ mypy timer.py
答案 19 :(得分:6)
我为此创建了一个库,如果你想测量一个函数,你可以像这样做
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)
答案 20 :(得分:4)
您可以使用timeit。
以下是如何使用Python REPL测试带参数的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
如果函数没有任何参数,则不需要包装函数。
答案 21 :(得分:4)
尽管在问题中没有严格要求,但通常情况下,您需要一种简单、统一的方法来增量地测量几行代码之间经过的时间。
如果您使用的是 Python 3.8 或更高版本,您可以使用 assignment expressions(又名海象运算符)以一种相当优雅的方式实现这一点:
import time
start, times = time.perf_counter(), {}
print("hello")
times["print"] = -start + (start := time.perf_counter())
time.sleep(1.42)
times["sleep"] = -start + (start := time.perf_counter())
a = [n**2 for n in range(10000)]
times["pow"] = -start + (start := time.perf_counter())
print(times)
=>
{'print': 2.193450927734375e-05, 'sleep': 1.4210970401763916, 'power': 0.005671024322509766}
答案 22 :(得分:4)
我喜欢它简单(Python 3):
from timeit import timeit
timeit(lambda: print("hello"))
一次执行的输出为微秒:
2.430883963010274
说明: 默认情况下,timeit执行一百万次匿名函数,结果以 seconds 给出。因此, 1次执行的结果是相同的数量,但平均为微秒。
对于慢操作,添加较低的数量迭代,否则您可能会一直等待:
import time
timeit(lambda: time.sleep(1.5), number=1)
总迭代次数数量的输出始终以秒表示:
1.5015795179999714
答案 23 :(得分:3)
作为 lambda,获取经过的时间和时间戳:
import datetime
t_set = lambda: datetime.datetime.now().astimezone().replace(microsecond=0)
t_diff = lambda t: str(t_set() - t)
t_stamp = lambda t=None: str(t) if t else str(t_set())
实践中:
>>>
>>> t_set()
datetime.datetime(2021, 3, 21, 1, 25, 17, tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=61200), 'PDT'))
>>> t = t_set()
>>> t_diff(t)
'0:00:14'
>>> t_diff(t)
'0:00:23'
>>> t_stamp()
'2021-03-21 01:25:57-07:00'
>>> t_stamp(t)
'2021-03-21 01:25:22-07:00'
>>>
答案 24 :(得分:3)
%load_ext snakeviz
%%snakeviz
只需在 Jupyter笔记本中使用这些 2行代码,即可生成一个漂亮的交互式图表。例如:
这是代码。同样,以%
开头的两行是使用snakeviz所需的仅有的额外代码行:
# !pip install snakeviz
%load_ext snakeviz
import glob
import hashlib
%%snakeviz
files = glob.glob('*.txt')
def print_files_hashed(files):
for file in files:
with open(file) as f:
print(hashlib.md5(f.read().encode('utf-8')).hexdigest())
print_files_hashed(files)
似乎也可以在笔记本电脑外部运行snakeviz。有关snakeviz website的更多信息。
答案 25 :(得分:3)
测量时间秒:
from timeit import default_timer as timer
from datetime import timedelta
start = timer()
end = timer()
print(timedelta(seconds=end-start))
答案 26 :(得分:2)
现在是2019年。让我们以一种简洁的方式做到这一点:
from ttictoc import TicToc
t = TicToc() ## TicToc("name")
t.tic();
# your code ...
t.toc();
print(t.elapsed)
使用此方法代替其他方法的优点:
t = TicToc(nested=True)
t.tic()
some code1...
t.tic()
some code2...
t.tic()
some code3...
print(t.toc()) # Prints time for code 3
print(t.toc()) # Prints time for code 2 with code 3
print(t.toc()) # Prints time for code 1 with code 2 and 3
t = TicToc("save user")
print(t.name)
有关详细说明,请参阅此link。
答案 27 :(得分:2)
时间单位:以秒为单位,以浮动为单位
import timeit
t = timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))')
t.timeit()
t.repeat()
>[1.2934070999999676, 1.3335035000000062, 1.422568500000125]
repeat()方法可以方便地多次调用timeit()并返回结果列表。
repeat(repeat=3)¶
使用此列表,我们可以平均地花费时间。
默认情况下,timeit()在计时期间临时关闭垃圾收集。 time.Timer()解决了这个问题。
优点:
timeit.Timer()使独立计时更具可比性。 gc可能是被测功能性能的重要组成部分。如果是这样,可以将gc(垃圾收集器)作为设置字符串中的第一条语句重新启用。例如:
timeit.Timer('li = list(map(lambda x:x*2,[1,2,3,4,5]))',setup='gc.enable()')
来源Python Docs!
答案 28 :(得分:2)
如果您希望能够方便地计时功能,可以使用一个简单的装饰器:
def timing_decorator(func):
def wrapper(*args, **kwargs):
start = time.time()
original_return_val = func(*args, **kwargs)
end = time.time()
print("time elapsed in ", func.__name__, ": ", end - start, sep='')
return original_return_val
return wrapper
您可以像这样在需要计时的功能上使用它:
@timing_decorator
def function_to_time():
time.sleep(1)
然后,每次调用function_to_time
时,它都会显示花费了多长时间以及函数的名称。
答案 29 :(得分:2)
基于https://stackoverflow.com/a/30024601/5095636给出的contextmanager解决方案,以下是lambda免费版本,因为flake8根据E731警告使用lambda:
from contextlib import contextmanager
from timeit import default_timer
@contextmanager
def elapsed_timer():
start_time = default_timer()
class _Timer():
start = start_time
end = default_timer()
duration = end - start
yield _Timer
end_time = default_timer()
_Timer.end = end_time
_Timer.duration = end_time - start_time
测试:
from time import sleep
with elapsed_timer() as t:
print("start:", t.start)
sleep(1)
print("end:", t.end)
t.start
t.end
t.duration
答案 30 :(得分:1)
这种独特的基于类的方法提供了可打印的字符串表示形式,可自定义的舍入功能,并且可以方便地访问作为字符串或浮点数的经过时间。它是使用Python 3.7开发的。
import datetime
import timeit
class Timer:
"""Measure time used."""
# Ref: https://stackoverflow.com/a/57931660/
def __init__(self, round_ndigits: int = 0):
self._round_ndigits = round_ndigits
self._start_time = timeit.default_timer()
def __call__(self) -> float:
return timeit.default_timer() - self._start_time
def __str__(self) -> str:
return str(datetime.timedelta(seconds=round(self(), self._round_ndigits)))
用法:
>>> timer = Timer()
>>> # Access as a string
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:03.
>>> print(f'Time elapsed is {timer}.')
Time elapsed is 0:00:04.
>>> # Access as a float
>>> timer()
6.841332235
>>> timer()
7.970274425
答案 31 :(得分:0)
import time
def getElapsedTime(startTime, units):
elapsedInSeconds = time.time() - startTime
if units == 'sec':
return elapsedInSeconds
if units == 'min':
return elapsedInSeconds/60
if units == 'hour':
return elapsedInSeconds/(60*60)
答案 32 :(得分:0)
timeit
模块非常适合计时一小段Python代码。它至少可以以三种形式使用:
1-作为命令行模块
python2 -m timeit 'for i in xrange(10): oct(i)'
2-对于短代码,请将其作为参数传递。
import timeit
timeit.Timer('for i in xrange(10): oct(i)').timeit()
3-对于更长的代码,如下:
import timeit
code_to_test = """
a = range(100000)
b = []
for i in a:
b.append(i*2)
"""
elapsed_time = timeit.timeit(code_to_test, number=100)/100
print(elapsed_time)
答案 33 :(得分:0)
时间也可以通过%timeit魔术功能来测量,如下所示:
%timeit -t -n 1 print("hello")
n 1
仅可运行1次。
答案 34 :(得分:0)
如何测量两次操作之间的时间。比较两个操作的时间。
import time
b = (123*321)*123
t1 = time.time()
c = ((9999^123)*321)^123
t2 = time.time()
print(t2-t1)
7.987022399902344e-05
答案 35 :(得分:0)
print_elapsed_time函数在下面
def print_elapsed_time(prefix=''):
e_time = time.time()
if not hasattr(print_elapsed_time, 's_time'):
print_elapsed_time.s_time = e_time
else:
print(f'{prefix} elapsed time: {e_time - print_elapsed_time.s_time:.2f} sec')
print_elapsed_time.s_time = e_time
以这种方式使用
print_elapsed_time()
.... heavy jobs ...
print_elapsed_time('after heavy jobs')
.... tons of jobs ...
print_elapsed_time('after tons of jobs')
结果是
after heavy jobs elapsed time: 0.39 sec
after tons of jobs elapsed time: 0.60 sec
此功能的优缺点是您不需要传递开始时间
答案 36 :(得分:0)
我能想到的唯一方法是使用time.time()
。
import time
start = time.time()
sleep(5) #just to give it some delay to show it working
finish = time.time()
elapsed = finish - start
print(elapsed)
希望这会有所帮助。
答案 37 :(得分:-2)
除了 ipython 中的%timeit
,您还可以将 %%timeit
用于多行代码段:
In [1]: %%timeit
...: complex_func()
...: 2 + 2 == 5
...:
...:
1 s ± 1.93 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
同样,它也可以在 jupyter笔记本电脑中使用,只需将magic %%timeit
放在单元格的开头即可。
答案 38 :(得分:-2)
更好地使用timeit :(它对同一命令运行多次,并给出结果)。
示例如下:
%timeit import pandas as pd