timeit与计时装饰器

Question

我在尝试给一些代码计时。首先，我用了一个计时的装饰器：

#!/usr/bin/env python

import time
from itertools import izip
from random import shuffle

def timing_val(func):
    def wrapper(*arg, **kw):
        '''source: http://www.daniweb.com/code/snippet368.html'''
        t1 = time.time()
        res = func(*arg, **kw)
        t2 = time.time()
        return (t2 - t1), res, func.__name__
    return wrapper

@timing_val
def time_izip(alist, n):
    i = iter(alist)
    return [x for x in izip(*[i] * n)]

@timing_val
def time_indexing(alist, n):
    return [alist[i:i + n] for i in range(0, len(alist), n)]

func_list = [locals()[key] for key in locals().keys()
             if callable(locals()[key]) and key.startswith('time')]
shuffle(func_list)  # Shuffle, just in case the order matters

alist = range(1000000)
times = []
for f in func_list:
    times.append(f(alist, 31))

times.sort(key=lambda x: x[0])
for (time, result, func_name) in times:
    print '%s took %0.3fms.' % (func_name, time * 1000.)

这个方法的结果是

% test.py
time_indexing took 73.230ms.
time_izip took 122.057ms.

然后我用了timeit这个工具：

%  python - m timeit - s '' 'alist=range(1000000);[alist[i:i+31] for i in range(0, len(alist), 31)]'
10 loops, best of 3:
    64 msec per loop
% 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:
    66.5 msec per loop

使用timeit得到的结果几乎是一样的，但用计时装饰器时，time_indexing看起来比time_izip快。

这之间的差异是什么原因呢？

这两种方法哪个更可信呢？

如果可信的话，应该相信哪一种呢？

Answer 1

我会使用一个计时装饰器，因为这样你可以通过注解的方式在代码中添加计时功能，而不需要让代码看起来乱七八糟。

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)

Answer 2

使用来自 functools 的包装功能来改进 Matt Alcock 的回答。

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

调用用 @timing 包装过的方法 f：

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

这样做的好处是，它保留了原始函数的属性；也就是说，像函数名称和文档字符串这样的元数据在返回的函数上得到了正确的保留。

Answer 3

使用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.