Why Python Dictionary Keys Overwrite Each Other: Hashing, Equality & Identity

First: Mysterious Dictionary Keys

some_dict = {}
some_dict[5.5] = "Ruby"
some_dict[5.0] = "JavaScript"
some_dict[5] = "Python"

Output shows that the key 5.5 returns "Ruby", 5.0 returns "Python", and 5 returns "Python", because Python treats 5 and 5.0 as the same key (they are equal and have the same hash), so the later assignment overwrites the previous value.

Python dictionaries compare keys by equality and hash value.

Immutable objects with the same value have identical hash values.

Different objects can still share a hash (collision).

>> 5 == 5.0
True
>>> hash(5) == hash(5.0)
True

Thus assigning some_dict[5] = "Python" replaces the earlier "JavaScript" entry.

Second: Return in Exception Handling

def some_func():
    try:
        return 'from_try'
    finally:
        return 'from_finally'

Calling some_func() returns 'from_finally' because the finally block always executes and its return overrides the one in try.

After a return, break, or continue in try, the finally clause still runs.

The function’s final return value is determined by the last executed return statement.

Third: Comparing Identical Objects

class WTF:
    pass

Examples:

>> WTF() == WTF()  # False
>>> WTF() is WTF()  # False
>>> hash(WTF()) == hash(WTF())  # True (hash collision)
>>> id(WTF()) == id(WTF())  # True (ids can repeat after object destruction)

Explanation: id() returns the memory address, which may be reused after an object is destroyed, so two separate objects can have the same id. The is operator checks identity, which remains False because the objects are distinct.