python writing a decorator with class

Question

here is my effort in writing a helper decorator module:

# -*- coding: utf8 -*-

import time
def timer(func):
    def timed(*args, **kwargs):
        init = time.clock()
        result = func(*args, **kwargs)
        print (time.clock()-init)*1000, 'ms'

        return result    
    return timed

class memo(object):
    def __init__(self, func):
        self.func = func
        self.memo = {}
        self.memohit = 0   

    def memoizedf(self, *args):
        key = tuple(args)
        print key
        lookup = self.memo.setdefault(key, None)
        if lookup:
            self.memohit += 1 
            return lookup

        result = self.func(*args)
        self.memo[key]=result
        return result

    def __call__(self, *args):
        return self.memoizedf(*args)

so, usage:

@timer
def foo():
    print 'foo'

'foo'
00023.1231203879 ms


@memo
def bar(fooobject):
    print fooobject

the problem comes here:

>>bar({'foo':'bar'})

traceback : ...........
    lookup = self.memo.setdefault(key, None)
TypeError: unhashable type: 'dict'

every input of list, dict, or other mutable from collections would invoke such error. I tried tupling all args, but apparently this didn't help. How should I rewrite my code in order to have my decorator to work with any(well, just dict, list, tuple, set, int, string... would be ok) kind of input?

there are many memoize recipes on the internet and Python 3.2+ comes with `functools.lru_cache` — JBernardo, Nov 08 '12 at 15:43
See http://stackoverflow.com/questions/4669391/python-anyone-have-a-memoizing-decorator-that-can-handle-unhashable-arguments — NPE, Nov 08 '12 at 15:44
you just couldn't use a mutable object for a key in a dict. Maybe you could use `str` to get a hashable representation of the object. — Facundo Casco, Nov 08 '12 at 15:46

score 1 · Answer 1 · answered Nov 08 '12 at 16:19

I'd suggest to serialize the mutable arguments before hashing, for example using the pickle module. The contents of any dict, list, or similar in the function arguments have to be picklable, otherwise a PicklingError will be raised. In your definition of memoizedf, you could use this code:

key = pickle.dumps((args,kwargs))
lookup = self.memo.setdefault(key, None)

A lot of objects are picklable, but not hashable, so this should extend the class of arguments that you can deal with significantly.

score -1 · Answer 2 · answered Nov 08 '12 at 16:20

-1

This will do the trick:

key = str(tuple(args))

answered Nov 08 '12 at 16:20

RickyA

15,465
5
71
95

The `str()` function is generally not guaranteed to return a useful result for memoizing objects. – silvado Nov 08 '12 at 16:23

python writing a decorator with class

2 Answers2