Prev: BeautifulSoup
Next: A simple-to-use sound file writer
From: Albert van der Horst on 13 Jan 2010 13:33
I have a type of objects that have complicated enough properties
to warrant a special class for its type.
The class has built in dictionary for all the properties.

Something along the line of
a = ctype({"poker":True})
b = ctype({"footbal":True, "gender":"m"})
c = ctype({"chess":True, "residence":"Amsterdam"})
I can count each type, again using a dictionary:
db = {}
db[a]=171
db[b]=208

But now I am at a loss as how to look up a ctype z in this db
dictionary efficiently, because all those objects are different
from z.

Is there a way to turn those ctype things into a hashable type?
(I would then convert z in the same way.)
Once a ctype is invented it never changes.
The only data pertinent to a ctype is its property dictionary.

(I encountered this before. A dictionary is a natural for a
boardgame position, i.e. chess. Now we want to look up chess
positions.)

Groetjes Albert

--
--
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert(a)spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst

From: Arnaud Delobelle on 13 Jan 2010 14:24
Albert van der Horst <albert(a)spenarnc.xs4all.nl> writes:

> I have a type of objects that have complicated enough properties
> to warrant a special class for its type.
> The class has built in dictionary for all the properties.
>
> Something along the line of
> a = ctype({"poker":True})
> b = ctype({"footbal":True, "gender":"m"})
> c = ctype({"chess":True, "residence":"Amsterdam"})
> I can count each type, again using a dictionary:
> db = {}
> db[a]=171
> db[b]=208
>
> But now I am at a loss as how to look up a ctype z in this db
> dictionary efficiently, because all those objects are different
> from z.
>
> Is there a way to turn those ctype things into a hashable type?
> (I would then convert z in the same way.)
> Once a ctype is invented it never changes.
> The only data pertinent to a ctype is its property dictionary.
>

Something like this will work (untested):

class ctype(object):
def __init__(self, propdict):
self.propdict = propdict
self._hash = hash(frozenset(propdict.items()))
def __hash__(self):
return self._hash
def __eq__(self, other):
return isinstance(other, ctype) and self.propdict == other.propdict

Note: you should capitalize your class names if you want to comply with
PEP 8.

HTH

--
Arnaud
From: Peter Otten on 13 Jan 2010 14:28
Albert van der Horst wrote:

> I have a type of objects that have complicated enough properties
> to warrant a special class for its type.
> The class has built in dictionary for all the properties.
>
> Something along the line of
> a = ctype({"poker":True})
> b = ctype({"footbal":True, "gender":"m"})
> c = ctype({"chess":True, "residence":"Amsterdam"})
> I can count each type, again using a dictionary:
> db = {}
> db[a]=171
> db[b]=208
>
> But now I am at a loss as how to look up a ctype z in this db
> dictionary efficiently, because all those objects are different
> from z.
>
> Is there a way to turn those ctype things into a hashable type?
> (I would then convert z in the same way.)
> Once a ctype is invented it never changes.
> The only data pertinent to a ctype is its property dictionary.

>>> class CType:
.... def __init__(self, data):
.... self.data = data
.... self._hash = hash(tuple(sorted(data.iteritems())))
.... def __hash__(self):
.... return self._hash
.... def __eq__(self, other):
.... return self._hash == other._hash and self.data == other.data
....
>>> a = CType({"poker":True})
>>> b = CType({"footbal":True, "gender":"m"})
>>> c = CType({"chess":True, "residence":"Amsterdam"})
>>> db = {}
>>> db[a]=171
>>> db[b]=208
>>> db[CType(dict(poker=True))]
171
>>> CType(dict(poker=False)) in db
False

Be very careful not to change the dictionary in the data attribute.
Otherwise you'll break your application.

Peter
From: Lie Ryan on 16 Jan 2010 02:23
On 01/14/10 05:33, Albert van der Horst wrote:
> (I encountered this before. A dictionary is a natural for a
> boardgame position, i.e. chess. Now we want to look up chess
> positions.)

or use collections.namedtuple
From: Ethan Furman on 16 Jan 2010 20:29
Lie Ryan wrote:
> On 01/14/10 05:33, Albert van der Horst wrote:
>
>>(I encountered this before. A dictionary is a natural for a
>>boardgame position, i.e. chess. Now we want to look up chess
>>positions.)
>
>
> or use collections.namedtuple

Which is great until you want to make a move. ;)

~Ethan~
 |  Next  |  Last
Pages: 1 2
Prev: BeautifulSoup
Next: A simple-to-use sound file writer