Op 2004-12-16, Jeff Shannon schreef <[EMAIL PROTECTED]>: > Antoon Pardon wrote: > >>Demanding that users of dictioanaries somehow turn their mutable objects >>into tuples when used as a key and back again when you retrieve the keys >>and need the object [...] >> > > But, you generally don't "retrieve" _keys_ from dicts. You *use* keys > to retrieve *values* from a dict. The only way to get a dict to give > you a key is by using the keys() method (or items() method) to give you > *all* of the keys. > > You say that mutating the keys inside of a dict is bad, and yet you want > keys to be mutable.
1) I don't want them to be mutable. If there was a way to mark individual objects as immutable, I wouldn't mind having all the keys in a dictionary so marked. But I do have objects that turn out to be mutable which are IMO usefull as keys in a dictionary, although I don't want to mutate the keys in dictionaries. > This seems to be an internally inconsistent position, That is because you didn't accurately presented it. > nevermind the fact that I can't think of a case where I'm > likely to "retrieve" a key from a dict, modify it, and then put it > back. (I can think of endless cases where I'd want to do that with > *values*, but not with keys...) Well neither can I, but yet the fact that lists are mutable and tuples are not, is frequently presented as reason why tuples are allowed as keys and tuples are not. > (And if dicts were somehow changed so that keys were copied when added > to a dict, just so that every once in a while someone might be able to > avoid a few conversions to/from tuple, then you're adding the overhead > of an object copy to *every* dict insertion, thus slowing down (possibly > by a significant amount) a large proportion of Python operations. How > is that a gain?) Well will look at two scenario's. In each we will work with mutable objects that we would like to use a keys. In the first we transform them into an immutable object, in the second we just allow mutables to be inserted as keys, but insert a copy of the key instead of the key itself in order to protect the programmer somewhat from mutating dictionary keys. Now in scenario one we will have a lot more copies then in scenario two, because each time we want to use an object as a key we will first have to transform it into an immutable. That means every addition to the dictionary as well as every key access and each such transform means a copy. In scenario two we will only make a copy when a key is added to the dictionary, we don't need to make copies with key accesses. I think scenario two is a performance gain over scenario one. -- Antoon Pardon -- http://mail.python.org/mailman/listinfo/python-list
