Interview Deep Dive: What Does This Print?

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Late binding

Looking a name up when the code runs, not when the function was written.

Closure

A function that keeps access to variables from the function that created it.

Free variable

A name a function uses but does not define itself.

Iterator

An object that hands out items one at a time with next() and can only be used once.

Iterable

Anything you can loop over; it can produce a new iterator whenever you ask.

Interning / caching

Reusing one object for equal small values to save memory.

Floating point

The way computers store decimals in binary. Many decimals, such as 0.1, can only be approximated.

1. 1

   Score yourself

   Cover the output of the first example and write your prediction for all six lines on paper. Run it. Count how many you got right, and for each wrong one, name the rule from the list above that decides it.

2. 2

   Fix the grid

   In the second example, replace grid = [row] * 2 with grid = [[0] * 3 for _ in range(2)] and run it. The comprehension runs [0] * 3 once per row, so every row is its own list.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

basket = ([1, 2], 3)
basket[0] += [10]
print(basket)

1. 1

   Late binding. Recall from Topic 5.7: a closure is a function that remembers variables from the place where it was made. A function looks up the names it uses (its free variables) when it runs, not when it is defined. [lambda: i for i in range(3)] creates three functions that all read the same i. By the time you call them, the loop is over and i is 2, so each prints 2. Fix it by capturing the current value as a default argument (lambda i=i: i) or with functools.partial.

2. 2

   Class versus instance attributes (Topic 8.2). An attribute is a named value stored on an object, and an instance is one object made from a class. Attribute lookup on an instance goes: the instance's own __dict__, then the class, then its base classes. Reading a.total finds the class attribute. Assigning a.total = 1 (or a.total += 1, which reads then assigns) always creates an attribute on the instance and leaves the class alone. Mutating a shared mutable class attribute, such as a.tags.append(...), changes it for every instance.

3. 3

   **+= on a tuple that holds a list.** t[0] += [10] does two steps: it calls list.__iadd__ on the list (which mutates it in place and succeeds), then tries to assign the result back to t[0], which a tuple forbids. So you get a TypeError and the list has still changed. This is the one puzzle where an exception and a side effect both happen.

4. 4

   Exhausted iterators. Recall from Topics 9.1 and 9.2: an iterator hands out one value at a time, and a generator is one kind of iterator. A generator, a map object and a file are iterators: they produce each value once and then are empty. Looping over a generator a second time gives nothing, with no error. A list is an iterable that can create a fresh iterator each time you loop. Many bugs come from passing a generator to code that loops twice (for example computing a sum and then a length).

5. 5

   Integer caching, float equality, banker's rounding. CPython reuses the integer objects from -5 to 256, so is seems to work for small numbers and then stops, which proves is is the wrong tool. 0.1 + 0.2 == 0.3 is False because binary floating point cannot store those decimals exactly; compare with math.isclose or work in decimal. round(2.5) is 2 because Python rounds ties to the nearest even number.

6. 6

   Dict and set ordering. Since Python 3.7, a dict remembers insertion order as a language guarantee, and re-assigning an existing key keeps its original position. Two dicts with the same items are == regardless of order. A set has no meaningful order, and the order of a set of strings can change between runs because string hashes (the numbers Python uses to find items quickly, Topic 4.5) are randomised for security.

• ↔

  Cleverness versus clarity. Puzzles reward knowing odd corners, but production code should avoid them. If a line needs a comment to explain what it prints, rewrite it.

• ↔

  **Default-argument capture versus partial.** lambda i=i: i is short but adds a parameter anyone could override by accident. functools.partial or a small factory function is more explicit.

• Done when you can state the four questions to ask about any output puzzle.

• Done when you can explain late binding and give two fixes.

• Done when you can say where a class attribute is read from and where += stores its result.

• Done when you can explain why t[0] += [10] both raises and mutates.

• Done when you can explain exhausted iterators, float equality and is on numbers in one sentence each.