Truthiness, None, and the mutable default

Four behaviours in this lesson. Each one runs without error while doing something other than what a TypeScript reflex expects, which makes them more expensive than syntax you get wrong loudly.

Empty containers are falsy

bool([])       # False
bool({})       # False
bool("")       # False
bool(set())    # False
bool(0)        # False
bool(None)     # False

In JavaScript, [] and {} are objects and objects are truthy, so if (results) tells you the variable holds something. In Python if results: tells you the variable holds something non-empty. Those are different questions, and Python’s answer is the more useful one about ninety percent of the time.

if not results:                # empty OR None. Usually what you want.
    return

if results is None:            # genuinely absent, distinct from empty
    results = fetch()

The trap is a function whose parameter is optional and whose empty case is meaningful. if not items: treats “the caller passed nothing” and “the caller passed an empty list on purpose” as the same event. Sometimes correct, sometimes a silent bug, and you have to decide which per function rather than by reflex.

None is the only absence

There is no undefined. A name is either bound or it is not, and reading an unbound name raises NameError or UnboundLocalError rather than evaluating to a second kind of nothing.

That collapses a distinction you are used to carrying, and it removes a whole family of TypeScript defensive code. It also removes the tools built around it: there is no optional chaining and no nullish coalescing.

name = user.name if user is not None else None    # no a?.b
timeout = configured if configured is not None else 30   # no a ?? b

The second one has a shorter idiom, timeout = configured or 30, which is exactly || and carries exactly the same bug: it also replaces 0, "" and False. It is fine for a string that cannot legitimately be empty and wrong for anything numeric.

Always test with is None, never == None. is compares identity, None is a singleton, and a class is free to define __eq__ in a way that makes x == None return something you did not expect. Every linter in the language flags == None.

is against ==

== compares value. is compares identity, meaning the same object in memory.

Coming from TypeScript there is a tempting false mapping: == is the loose one, === is the strict one, so is must be ===. It is not. Python’s == already does no type coercion, so it is already the strict comparison you wanted. is is a third thing with no TypeScript equivalent except reference equality.

a = 256
b = 256
a is b        # True, in CPython. Small ints are cached.

a = 257
b = 257
a is b        # False. Outside the cache.

Nothing about that is guaranteed by the language and none of it is something to rely on. It matters only because it means is on integers and strings appears to work in a REPL and on small test data, then fails on a real value. Use is for None, True and False. Nothing else.

The mutable default argument

This one is famous, and the fame is deserved.

def add_tag(tag, tags=[]):
    tags.append(tag)
    return tags

add_tag("a")    # ['a']
add_tag("b")    # ['a', 'b']   <- the same list, still there
add_tag("c")    # ['a', 'b', 'c']

The default expression is evaluated once, when the def statement runs, and the resulting object is stored on the function. Every call that omits the argument gets that same object. If the object is mutable, mutations accumulate for the lifetime of the process.

TypeScript evaluates a default parameter on every call that omits it, so this is a genuine language difference and not a gotcha you can reason your way to from first principles.

def add_tag(tag, tags=None):
    if tags is None:
        tags = []
    tags.append(tag)
    return tags

You will see that three-line shape constantly. Now you know it is not defensive noise: it is the only correct way to write a mutable default.

Assignment never copies

a = [1, 2, 3]
b = a
b.append(4)
a            # [1, 2, 3, 4]

Identical to JavaScript, and worth saying out loud anyway because Python’s lack of const removes the visual cue you are used to. There is no const, no readonly, and no frozen-by-default anything. If you want a copy, ask for one: b = a.copy() or b = a[:] for a shallow one, copy.deepcopy(a) for the recursive one.

The immutable types are str, int, float, bool, tuple, frozenset and bytes. Everything else is mutable and shared.

Where this goes

That is the whole set of Python behaviours that will silently do the wrong thing when you write TypeScript by reflex. The next lesson is objects: self, __init__, the dunder protocols, and why nothing is private.