Scoping, closures & dunder protocols

There is no prototype chain. There is no this binding to reason about. In exchange you get an explicit lookup order and a set of named protocol hooks. That is more verbose, and considerably easier to predict.

LEGB

Name lookup walks four scopes in order: Local → Enclosing → Global → Built-in. One rule catches people. Assigning to a name anywhere in a function makes it local for the entire function, including the lines above the assignment.

count = 0  # global
def read_only():
    print("reads the global fine:", count)
def broken():
    try:
        print(count)   # UnboundLocalError: 'count' is local because of the line below
        count = 1
    except UnboundLocalError as e:
        print("UnboundLocalError:", e)
def fixed():
    global count
    count += 1
read_only()
broken()
fixed()
print("after fixed():", count)

JavaScript has no equivalent. let n = 0 in an outer scope is simply writable from a closure. Python makes you declare the intent. Use nonlocal for an enclosing function scope, global for module scope.

def make_counter():
    n = 0
    def increment():
        nonlocal n     # without this: UnboundLocalError
        n += 1
        return n
    return increment
counter = make_counter()
print(counter(), counter(), counter())

Late binding

Closures capture the variable, not its value at creation time. This is the pre-ES6 var bug, and Python has no let to fix it with.

broken = [lambda: i for i in range(3)]
print([f() for f in broken])       # [2, 2, 2] — all share one 'i'
fixed = [lambda i=i: i for i in range(3)]
print([f() for f in fixed])        # [0, 1, 2] — default binds at definition

The fix deliberately uses the mutable-default mechanism from Module 1: a default argument is evaluated when the lambda is created, which is exactly the snapshot you want.

Signatures

Everything after a bare * is keyword-only. It is the cheapest API design tool Python has. It stops callers passing three positional booleans, and makes every call site self-documenting.

def configure(*, api_key: str, timeout: int = 30, retries: int = 3):
    return f"key={api_key} timeout={timeout} retries={retries}"
print(configure(api_key="sk-123", timeout=5))
try:
    configure("sk-123", 5)     # positional is rejected
except TypeError as e:
    print("TypeError:", e)
def log(level, *parts, **fields):
    return f"[{level}] {' '.join(parts)} {fields}"
print(log("INFO", "user", "created", user_id=7))

Dunder protocols

Where JavaScript has Symbol.iterator, toString and a handful of well-known symbols, Python has a full protocol table. Implement the method, get the syntax.

__init__ is the constructor. self is explicit, it is the first parameter of every method, and nothing binds it for you. That verbosity is why Python never needed .bind(this).

class Tags:
    def __init__(self, *names):
        self._names = list(names)
    def __len__(self):
        return len(self._names)
    def __getitem__(self, key):
        return self._names[key]        # slices work for free
    def __repr__(self):
        return f"Tags({', '.join(self._names)})"
    def __contains__(self, name):
        return name in self._names
t = Tags("python", "wasm", "typescript")
print(len(t), t[0], t[-1], t[0:2])
print("wasm" in t)
print(t)
for name in t:                          # __getitem__ alone is enough to iterate
    print(" -", name)

MRO

Python supports multiple inheritance and resolves it with C3 linearization. super() follows the MRO, not "the parent class". In a diamond, super() inside A may well call B.

class Base:
    def who(self):
        return "Base"
class A(Base):
    def who(self):
        return "A -> " + super().who()
class B(Base):
    def who(self):
        return "B -> " + super().who()
class C(A, B):
    pass
print(C().who())
print([cls.__name__ for cls in C.__mro__])

Properties

@property turns a method into a read-only attribute. Unlike a JavaScript getter it can be retrofitted onto an existing public attribute without changing a single call site, which is why Python code rarely has getX() methods in the first place.

Kata

Build a collection that behaves like a built-in.

class DataBatch:
    def __init__(self, values):
        self.values = list(values)
    # __len__
    # __getitem__   (remember: key may be an int or a slice)
    # __add__
    # __repr__
    # mean as a @property