Interview Deep Dive: Core Language Questions

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

Name

A label in your code, such as scores, that refers to an object. Assignment (=) attaches a name to an object.

Identity

Which exact object something is. is compares identity; id(x) shows it in CPython.

Mutable

Able to change in place after it is created, like a list.

Immutable

Unable to change after it is created, like a number, a string or a tuple.

Shallow copy

A new outer container whose contents are the same objects as the original's.

Deep copy

A copy of the container and, recursively, of everything inside it.

Falsy / truthy

Whether a value counts as false or true inside if and while.

LEGB

The order Python searches scopes: Local, Enclosing, Global, Built-in.

1. 1

   Predict, then run

   Before pressing Run on the first example, write down what you expect for lines 1, 3 and 6 of its output. Then run it. For every line you got wrong, say in one sentence which rule (names, shallow copy, immutability) explains the real output.

2. 2

   Fix the shared default

   In the second example, call add_bad(3) a third time and predict the printed list before you run it. Then change the add_bad calls to add_good and see the shared state disappear. Finally, write a version whose default is the tuple () and which returns bucket + (item,): tuples are immutable, so a default tuple is safe. Decide which version you would approve in a code review.

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

counter = 0


def bump():
    counter += 1
    return counter


print(bump())

1. 1

   Mutable and immutable. An object is mutable if it can change in place (list, dict, set, and most objects made from your own classes, Topic 8.1) and immutable if it cannot (int, float, str, tuple, frozenset, bytes). Assignment never copies: b = a makes a second name for the same object. The precise interview answer is that variables are names bound to objects, so b = a followed by a.append(4) shows up through b. Immutability is shallow: a tuple cannot change which objects it holds, but a list inside it can still change.

2. 2

   **is versus ==.** == asks "do these two objects have equal values?" and calls the special method __eq__ (Topic 8.7). is asks "are these the very same object?" and compares identity (what id() returns) without calling any method. Use == for values and is only for singletons, objects of which there is only one, above all None. Never use is to compare numbers or strings. CPython (the standard program that runs Python code) happens to cache small integers and some strings, which makes is look right until it silently is not.

3. 3

   Default arguments are evaluated once, when the def statement runs, not on each call. Recall from Topic 5.2: a default is the value a parameter gets when the caller leaves it out. A mutable default such as bucket=[] is therefore one shared list for the life of the function, stored in fn.__defaults__. The standard fix is bucket=None and if bucket is None: bucket = [] inside the body. The same rule explains why a default like time=now() is frozen at definition time.

4. 4

   Scope follows LEGB (Topic 5.5). Scope means where a name can be seen. Python looks a name up in the Local scope, then any Enclosing function, then the Global (module) scope, then Built-ins. The compiler decides, before running, that a name assigned anywhere in a function is local to that whole function. That is why counter += 1 inside a function raises UnboundLocalError even though a global counter exists. global and nonlocal are the explicit opt-outs. Reading a global needs no keyword; rebinding it does.

5. 5

   Copying has three levels. Assignment copies nothing. A shallow copy (list(a), a.copy(), a[:], copy.copy(a)) makes a new outer container but shares the inner objects. A deep copy (copy.deepcopy(a)) copies the whole tree and handles cycles (objects that refer back to each other). The classic trap is a list of lists: a shallow copy shares the rows, and [[0] * 3] * 2 repeats one row twice.

6. 6

   Truthiness and comprehensions. These values are falsy: None, False, zero of any numeric type (0, 0.0, 0j), and empty containers and strings ("", [], (), {}, set(), range(0)). Everything else is truthy, including the string "0" and the list [0]. An object of your own class is truthy unless the class defines the special methods __bool__ or __len__ (Topic 8.7). A comprehension has its own scope, so its loop variable does not leak into the surrounding code.

• ↔

  Deep copy versus sharing. Deep copies protect you from accidental sharing but cost time and memory. Sharing immutable data is free and safe; copy only when you must mutate.

• ↔

  **Explicit is None versus truthiness.** if items: is short and idiomatic for containers. if value is None: is exact when 0 or empty is a valid answer. Pick the one that matches what you mean.

• Done when you can explain names, objects and identity using the locker analogy.

• Done when you can say, with proof, why add(x, bucket=[]) leaks state and write the fix.

• Done when you can predict a shallow-versus-deep copy result on nested lists.

• Done when you can explain UnboundLocalError and choose between global, nonlocal and passing values.

• Done when you can list the falsy values and name two surprising truthy ones.