dict's as dict's key.

[Albert van der Horst]

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=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

 

[Arnaud Delobelle]

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=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

 

[Peter Otten]

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=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.

.... 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=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

 

[Lie Ryan]

(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

 

[Ethan Furman]

or use collections.namedtuple

Which is great until you want to make a move.

~Ethan~

 

[Lie Ryan]

Which is great until you want to make a move.

No problem, just create a new namedtuple.

The OP wanted fast attribute lookup and AFAICT doesn't mention anything
about fast construction.