Types, identity, and mutability

== asks whether two values are equal. is asks whether two names point at the same object in memory. They usually agree by accident for small integers and interned strings, which is exactly what makes is dangerous to reach for out of habit.

a = [1, 2, 3]
b = [1, 2, 3]
a == b   # True  — same contents
a is b   # False — two different list objects

x = 5
y = 5
x is y   # True — small ints are cached, but this is an implementation detail

is has exactly one correct everyday use: comparing against None. value is None, never value == None — None is a singleton, so is is both correct and cannot be fooled by a class's own __eq__, and it is the style PEP 8 asks for.

Mutable and immutable

str, int, float, bool, and tuple are immutable — nothing can change them in place; every "modification" makes a new object. list, dict, and set are mutable — the same object can change shape without a new one being created.

s = "hello"
s.upper()        # returns "HELLO", a new string
s                 # still "hello" — s itself never changed

nums = [1, 2, 3]
nums.append(4)    # mutates nums in place
nums              # [1, 2, 3, 4] — the same list object, changed

Try it

The mutable default argument trap

A default argument is evaluated once, when the def runs — not on every call.

def add_item(item, into=[]):
    into.append(item)
    return into

add_item("a")   # ['a']
add_item("b")   # ['a', 'b'] — the same list, remembered from last time

Every call that does not pass into shares and mutates the exact same list, because that list was created once, at definition time, not fresh per call. The fix is the standard sentinel:

def add_item(item, into=None):
    if into is None:
        into = []
    into.append(item)
    return into

This is the single most common source of a "how does this function already have data in it the first time I call it" bug in Python, and it reaches beyond lists: every default expression is evaluated once, so a default {} used as a cache is shared by every call, and a default datetime.now() is frozen at the moment the def ran.

Common mistakes

• Writing into = into or [] instead of if into is None. An empty list is falsy, so a caller who passes their own empty list gets a brand-new one back and their list never sees the item (with_or above stays []).
• Using is to compare numbers or strings. It happens to work for small integers, which CPython caches, and fails for larger ones built at runtime — big_is below is False although the values are equal.
• Assuming a tuple freezes what it holds. The tuple's slots cannot be reassigned, but a list inside it can still grow, and a tuple holding a list cannot be hashed.

What interviewers ask

• What is the difference between is and ==? Identity against equality; is is for None and other singletons or sentinels, never for comparing values.
• Why is def f(x=[]) a bug, and how do you fix it? The default is built once, when def runs, and shared by every call; default to None and create the list inside.
• Is a tuple that contains a list immutable? Its own references are fixed, but the list inside can change, which is also why such a tuple is unhashable.