Python timeit.timeit在语句之间执行非定时操作

Question

I have a recursive function that has a functools.lru_cache() decorator on it. I want to time the execution of it from an empty cache multiple times. One way to do that is clear the cache every time, but this includes the cache clearing time.

This is what I currently have:

@functools.lru_cache(maxsize=None)
def recursive_function(n):
    # ...
    return sum(recursive_function(n - i) * b for i, b in enumerate(other_list))

def time(number, n):
    return timeit.timeit(
        'f({}); f.cache_clear()'.format(n),
        'from {} import recursive_function as f'.format(__name__),
        number=number
    )

I still want to time it with a cache, as the cache reduces the time exponentially, but after it has been called once, calling it again takes ~0ms, as it just gets the cached value.

Is there a way to do something between statements in timeit.timeit without it counting towards the time? Or to pause the timer before the cache_clear?

Answer 1

You could produce number copies of the function, each with their independent lru_cache wrapper:

setup = '''\
    from {name} import recursive_function as f
    f = iter([
        functools.lru_cache(maxsize=None)(recursive_function.__wrapped__)
        for _ in range({number})])
    n = {n}
    next_ = next
'''.format(name=__name__, number=number, n=n)
test = '''\
    recursive_function = next_(f)
    recursive_funcion.__globals__['recursive_funcion'] = recursive_funcion
    recursive_function(n)
'''
return timeit.timeit(test, setup, number=number)

The setup creates number individually decorated function objects up front , each with a distinct LRU cache, and creates an iterator for this. The test then uses the next() function to obtain the next available function object, and uses that for the test.

You do have to replace the current global name recursive_function each time however, as otherwise the recursive call won't find the new decorated version. This is a bit of a downside, don't run the time trial and expect the cache to be empty afterwards (it'll contain the results of the very last test run instead).

This works because:

1. the original un-cached function is still available as recursive_function.__wrapped__
2. decorator syntax is just syntactic sugar for a call to the decorator object to produce a new function object.

This gives each individual test a clean cache, with minimal overhead (only a next() call, which has been bound to a local to avoid the global name lookup penalty).