Antoon Pardon wrote:
Op 2004-12-17, Jeff Shannon schreef <[EMAIL PROTECTED]>:
Now, even if hash were made to equal id... suppose I then pass that dict to a function, and I want to get the value that I've stored under [1,2]. In order to do that, I'd *also* have to pass in the *exact* list that I used as the key, because *only* that *exact* instance will hash correctly.
Maybe that is what I want.
Then use a class instance, rather than a list. It's too valuable elsewhere to have lists that compare by value rather than identity.
That doesn't change the fact that conceptually a programmer can use
them that way. So do you think that if a programmer uses a list
as a heap or a sorted list he should limit his object to immutable
objects. Are you saying that programmers shouldn't sort mutable
objects.
I'm saying that your analogy of list/heap *values* to dictionary *keys* is a bogus analogy. Dictionary *values* have no restrictions against mutation, just as list/heap values have no restrictions.
I'm also saying that a sorted/heaped list can be easily fixed by examining the items in it. A broken hash table *cannot* be fixed that way.
Note also that, if a list becomes unsorted or unheaped, it's fairly easy to resort or re-heapify the list. It may take some time, but nothing is lost. If a dictionary key mutates, then data *is* lost.
Is it? I don't see why an items method should fail to provide all (key,
value) pairs even when keys were mutated.
How does the dict know which value is associated with which key?
I need to be able to access sequence-keyed dictionaries with literals, which means that the keys need to compare by value, not ID. Thus, I need to have sequences that compare (and hash) by value. These conditions *cannot* be met by a mutable list. I can have the quality of hash value not changing when mutated, or I can have the quality of hashing by value, but I *cannot* have both. Thus, even if you make lists hash by ID, I *still* need to have an immutable tuple type so that I can get hash-by-value.
Given that lists simply cannot replace every usage of tuples as dictionary keys, the question becomes only one of which is more important -- that lists compare to each other by value, or that lists are usable as dictionary keys. Given the ease of using compare-by-ID class instances instead of lists, and the general usefulness of having lists compare by value, I think that Python made the right choice.
Jeff Shannon Technician/Programmer Credit International
-- http://mail.python.org/mailman/listinfo/python-list
