Why Python Overwrites Dict Entries with 5 vs 5.0 and Other Hidden Behaviors

First: Mysterious Dictionary Keys

Python dictionaries consider keys equal if they compare equal and have the same hash value. Immutable objects with the same value always have the same hash.

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

Output:

>> some_dict[5.5]
"Ruby"
>>> some_dict[5.0]
"Python"
>>> some_dict[5]
"Python"

Python dictionaries determine key equality by checking both equality and hash value.

Immutable objects with identical values share the same hash.

Note: Different objects can also share the same hash (hash collisions).

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

When executing some_dict[5] = "Python", the key 5 is recognized as the same key as 5.0, so the existing value "JavaScript" is overwritten.

Second: Return in Exception Handling

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

Output:

>> some_func()
'from_finally'

In a try...finally block, the finally clause always runs, even after return, break, or continue.

The function’s return value is determined by the last executed return statement; because finally always executes, its return overrides earlier returns.

Third: Equality of Identical Objects

class WTF:
    pass

Output:

>> WTF() == WTF()  # two different objects should not be equal
False
>>> WTF() is WTF()
False
>>> hash(WTF()) == hash(WTF())
True
>>> id(WTF()) == id(WTF())
True

The id() function creates a temporary object, passes it to id, then discards it; the next call may reuse the same memory address.

Thus, id values are only unique during an object’s lifetime; after destruction, other objects can receive the same id.

The is operator checks object identity, which remains False because the objects are distinct, even if their id values coincide.