0.000112s (Antonio’s 2nd version)
0.000155s (your version)

But if you remove missing, the time goes down to 0.000099s:

def memoize2(function):
cache = {}
def decorated_function(*args):
val = cache.get(args)
if not val:
val = function(*args)
cache[args] = val
return val
return decorated_function

“if args in cache” seems safer, though. If function(*args) == None, it will always be reevaluated for args. Functions can also return object(), although that is admittedly less likely.

def memoize(function):
    cache = {}
    def decorated_function(*args):
        missing = object()
        val = cache.get(args, missing)
        if not val is missing:
            return val
        else:
            val = function(*args)
            cache[args] = val
            return val
    return decorated_function

As a micro-optimisation you could make both cache and missing keyword arguments to the inner function. Lookup of local variables is faster. Not benchmarked any of this…

An example would be a result from a complex database query.

So memoization will work for function without parameters, but only if this function always return the same value 🙂 so it is not very useful.

BTW it works in such way – each call to function first checks if the function was called with the same arguments before, if it was, it returns the value it returned last time, if not, it calculates the value normally, and then keeps the value associated with parameters it was called.

So it is simple caching, and can be only used on “pure” (as in functional programming) functions.

user system total real
Regular fib: 7.955000 0.000000 7.955000 ( 7.955000)
Memoized fib: 0.004000 0.000000 0.004000 ( 0.004000)