timeit против декоратора времени

Используйте timeit. Выполнение теста более одного раза дает мне гораздо лучшие результаты.

func_list=[locals()[key] for key in locals().keys() 
           if callable(locals()[key]) and key.startswith('time')]

alist=range(1000000)
times=[]
for f in func_list:
    n = 10
    times.append( min(  t for t,_,_ in (f(alist,31) for i in range(n)))) 

for (time,func_name) in zip(times, func_list):
    print '%s took %0.3fms.' % (func_name, time*1000.)

->

<function wrapper at 0x01FCB5F0> took 39.000ms.
<function wrapper at 0x01FCB670> took 41.000ms.

Используйте упаковку из functools, чтобы улучшить ответ Мэтта Алкока.

from functools import wraps
from time import time

def timing(f):
    @wraps(f)
    def wrap(*args, **kw):
        ts = time()
        result = f(*args, **kw)
        te = time()
        print 'func:%r args:[%r, %r] took: %2.4f sec' % \
          (f.__name__, args, kw, te-ts)
        return result
    return wrap

В примере:

@timing
def f(a):
    for _ in range(a):
        i = 0
    return -1

Вызов метода f, заключенного в @timing:

func:'f' args:[(100000000,), {}] took: 14.2240 sec
f(100000000)

Преимущество этого метода в том, что он сохраняет атрибуты исходной функции; то есть метаданные, такие как имя функции и строка документации, правильно сохраняются в возвращаемой функции.

Я бы использовал декоратор времени, потому что вы можете использовать аннотации, чтобы распределить время вокруг вашего кода, вместо того, чтобы запутывать код с логикой синхронизации.

import time

def timeit(f):

    def timed(*args, **kw):

        ts = time.time()
        result = f(*args, **kw)
        te = time.time()

        print 'func:%r args:[%r, %r] took: %2.4f sec' % \
          (f.__name__, args, kw, te-ts)
        return result

    return timed

Использовать декоратор просто, либо использовать аннотации.

@timeit
def compute_magic(n):
     #function definition
     #....

Или измените псевдоним функции, на которую вы хотите рассчитать время.

compute_magic = timeit(compute_magic)

Я устал от from __main__ import foo, теперь используйте это - для простых аргументов, для которых работает% r, а не в Ipython.
(Почему timeit работает только со строками, а не с преобразователями / замыканиями, т.е. timefunc (f, произвольные аргументы) ?)

import timeit

def timef( funcname, *args, **kwargs ):
    """ timeit a func with args, e.g.
            for window in ( 3, 31, 63, 127, 255 ):
                timef( "filter", window, 0 )
    This doesn't work in ipython;
    see Martelli, "ipython plays weird tricks with __main__" in Stackoverflow        
    """
    argstr = ", ".join([ "%r" % a for a in args]) if args  else ""
    kwargstr = ", ".join([ "%s=%r" % (k,v) for k,v in kwargs.items()]) \
        if kwargs  else ""
    comma = ", " if (argstr and kwargstr)  else ""
    fargs = "%s(%s%s%s)" % (funcname, argstr, comma, kwargstr)
        # print "test timef:", fargs
    t = timeit.Timer( fargs, "from __main__ import %s" % funcname )
    ntime = 3
    print "%.0f usec %s" % (t.timeit( ntime ) * 1e6 / ntime, fargs)

#...............................................................................
if __name__ == "__main__":
    def f( *args, **kwargs ):
        pass

    try:
        from __main__ import f
    except:
        print "ipython plays weird tricks with __main__, timef won't work"
    timef( "f")
    timef( "f", 1 )
    timef( "f", """ a b """ )
    timef( "f", 1, 2 )
    timef( "f", x=3 )
    timef( "f", x=3 )
    timef( "f", 1, 2, x=3, y=4 )

Добавлено: см. Также «ipython играет странные трюки с main», Мартелли в running-doctests-through-ipython < / а>

Это тот тип потребностей, о котором вы молитесь, чтобы библиотека предоставила портативное решение - СУХОЕ! К счастью, funcy.log_durations приходит к ответу.

Пример скопирован из документации:

@log_durations(logging.info)
def do_hard_work(n):
    samples = range(n)
    # ...

# 121 ms in do_hard_work(10)
# 143 ms in do_hard_work(11)
# ...

Просмотрите документацию по funcy, чтобы узнать о других вариантах, таких как различные аргументы ключевого слова и @log_iter_durations.

Вдохновленный ответом Мики Смита, я вместо этого сделал прямую печать (и не использовал модуль ведения журнала).

Ниже удобно использовать в Google Colab.

# pip install funcy
from funcy import print_durations

@print_durations()
def myfunc(n=0):
  for i in range(n):
    pass

myfunc(123)
myfunc(123456789)

# 5.48 mks in myfunc(123)
# 3.37 s in myfunc(123456789)

Просто предположение, но может ли разница быть на порядок разницы в значениях range ()?

Из вашего первоисточника:

alist=range(1000000)

Из вашего timeit примера:

alist=range(100000)

Как бы то ни было, вот результаты в моей системе с диапазоном, установленным на 1 миллион:

$ python -V
Python 2.6.4rc2

$ python -m timeit -s 'from itertools import izip' 'alist=range(1000000);i=iter(alist);[x for x in izip(*[i]*31)]'
10 loops, best of 3: 69.6 msec per loop

$ python -m timeit -s '' 'alist=range(1000000);[alist[i:i+31] for i in range(0, len(alist), 31)]'
10 loops, best of 3: 67.6 msec per loop

Мне не удалось запустить другой ваш код, так как я не мог импортировать модуль "декоратор" в свою систему.

Обновление. Я вижу то же несоответствие, что и вы, когда запускаю ваш код без участия декоратора.

$ ./test.py
time_indexing took 84.846ms.
time_izip took 132.574ms.

Спасибо, что разместили этот вопрос; Я кое-что узнал сегодня. знак равно

независимо от этого конкретного упражнения, я полагаю, что использование timeit намного безопаснее и надежнее. он также кроссплатформенный, в отличие от вашего решения.