Syntax Rosetta & memory foundations

You can read Python already. That is the problem. The syntax is close enough that you will translate it in your head and be wrong about four things per file. This module fixes the four.

Nullity

JavaScript ships two empty values. Python ships one.

None is a singleton, so is None is both the idiomatic and the correct test. == None works by accident until someone defines __eq__, and then it stops working.

missing = None
print(missing is None)
d = {"a": 1}
print(d.get("b"))           # like obj.b -> undefined
print(d.get("b", "default"))
# There is no ?. — this raises rather than returning undefined
try:
    print(d["b"])
except KeyError as e:
    print("KeyError:", e)

Truthiness

This is the divergence that silently changes behaviour when you port code.

print(bool([]))    # False — empty containers are falsy
print(bool({}))    # False
print(bool(""))    # False
print(bool(0))     # False

In JavaScript, if (arr) asks does this array exist. In Python, if xs: asks does this list have anything in it. Ported directly, that check flips meaning. When you meant existence, say if xs is not None:.

Equality and identity

== compares values through __eq__. is compares object identity, it is Object.is, not ===. Reserve it for None, True and False.

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b, a is b)   # equal values, different objects
print(a == c, a is c)   # same object
# CPython interns small integers, which makes 'is' look like it works.
# (No literals on either side of is — Python 3.12+ warns on that.)
small = 256
big = 257
zero = 0
print(small is small + zero, big is big - zero)

Strings and slicing

Two traps live here.

xs = [0, 1, 2, 3, 4, 5]
print(xs[-1])      # last
print(xs[-3:])     # last three
print(xs[::-1])    # reversed copy
print(xs[::2])     # every second element
# str.replace is global by default — this is the one that bites
print("a-b-c".replace("-", "+"))
print("a-b-c".replace("-", "+", 1))

EAFP over LBYL

JavaScript style is Look Before You Leap. Guard with ?., then act. Python style is Easier to Ask Forgiveness than Permission. Act, then catch. A try block that raises nothing costs essentially nothing, so the guard buys you no performance and one more branch to keep in sync.

# LBYL, reads like JavaScript, and races if the dict is shared
if "key" in config and config["key"] is not None:
    use(config["key"])

# EAFP, idiomatic
try:
    use(config["key"])
except KeyError:
    use_default()

Hashability

Dict keys and set members must be hashable, which in practice means immutable. This has no JavaScript analogue, a Map accepts any object as a key, by reference.

ok = {(1, 2): "tuples are fine", "s": "so are strings", 7: "and ints"}
print(ok[(1, 2)])
try:
    broken = {[1, 2]: "value"}
except TypeError as e:
    print("TypeError:", e)

Comprehensions

.map().filter() chains become one comprehension. Same for dicts and sets. Swap the brackets for parentheses and you get a lazy generator instead of a materialised list, the equivalent of a function*, and what you want when the sequence is large.

users = [{"id": 1, "name": "ada", "age": 36}, {"id": 2, "name": "grace", "age": 45}]
names = [u["name"] for u in users if u["age"] > 40]
by_id = {u["id"]: u for u in users}
lazy = (u["name"] for u in users)
print(names, list(by_id), next(lazy))

Unpacking

Kata

Two bugs, both of which look correct to a JavaScript reader.

def accumulate(item, into=[]):
    into.append(item)
    return into
def same_contents(a, b):
    return a is b