Interview Deep Dive: OOP and Internals

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

MRO

Method resolution order: the list of classes Python searches, in order, when you call a method.

super()

A proxy that looks for the next class after the current one in the MRO.

Descriptor

A class attribute whose object has __get__, __set__ or __delete__ and controls how that attribute is read and written.

GIL

The global interpreter lock: in the default CPython build, one thread runs Python bytecode at a time.

Reference count

A number stored on every object: how many names and containers refer to it. At zero the object is freed.

Cyclic garbage collector

A background pass that frees groups of objects that refer to each other and are no longer reachable.

Context manager

An object used in a with statement that sets something up and always tears it down.

Bound method

A function with self already attached, such as obj.method.

1. 1

   Predict the MRO

   Add a class E(C, B) to the first example and then a class F(D, E). Before running, try to predict F.__mro__. Python will refuse with a TypeError because D wants B before C and E wants C before B. Read the message, then fix it by changing the order of the bases.

2. 2

   Break the cleanup

   In the second example, remove the try/finally from opened and rerun. The 'close' line disappears when the body raises. That is the bug context managers exist to prevent.

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

class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y


p = Point(1, 2)
p.z = 3

1. 1

   **MRO and super() (Topic 8.6). Python uses C3 linearization**: the MRO of a class lists the class, then its parents, merged so that every class comes before its own parents and the order of the bases you wrote is kept. You can print it with D.__mro__. In a diamond (D(B, C), both B and C extend A) the MRO is D, B, C, A, object, so super().hello() inside B calls **C**, a class B knows nothing about. That is what makes cooperative multiple inheritance work, and why every method in the chain must call super().

2. 2

   **__new__ versus __init__.** Creating an instance has two steps. __new__(cls, ...) is a static-like method that creates and returns the object. Then, if the result is an instance of cls, Python calls __init__(self, ...) to initialise it. Override __new__ for immutable types (a subclass of int or str), for singletons, and for caching instances. Override __init__ for everything else.

3. 3

   Descriptors (Topic 13.5). An object with __get__ (and optionally __set__ or __delete__) stored as a class attribute takes over attribute access. A data descriptor (has __set__) beats the instance __dict__; a non-data descriptor (only __get__) loses to it. Functions are non-data descriptors: that is how obj.method becomes a bound method with self filled in. property, classmethod, staticmethod and __slots__ members are all descriptors, as are the validated fields in the example below.

4. 4

   The GIL and memory (Topics 12.2 and 13.2). A thread is one line of work inside a program, and bytecode is the low-level instruction list Python compiles your code into (Topic 13.3). In the standard CPython build the global interpreter lock (GIL) lets only one thread run Python bytecode at a time. Threads still help for I/O-bound work (work that mostly waits for the network or disk), because a thread waiting on the network releases the lock. They do not speed up CPU-bound pure-Python loops; use processes (multiprocessing, ProcessPoolExecutor) or native code such as NumPy. Python 3.13 added an experimental free-threaded build without the GIL, and 3.14 officially supports it, but the default build still has the GIL. Memory is managed by reference counting (an object is freed the instant its count reaches zero) plus a cyclic garbage collector that finds groups of objects that only reference each other.

5. 5

   Decorators, generators, iterators (Topics 9.6, 9.2 and 9.1). A decorator is just a function that takes a function and returns a function: @logged above def add means add = logged(add). Use functools.wraps so the wrapper keeps the original's __name__ and docstring. An iterator has __iter__ (returning itself) and __next__. A generator is a function containing yield: calling it returns an iterator whose body runs lazily, pausing at each yield. All generators are iterators; not all iterators are generators.

6. 6

   **__slots__ and context managers.** __slots__ = ('x', 'y') removes the per-instance __dict__, saving memory when you create millions of small objects, and makes typos like p.z = 3 an AttributeError. Recall from Topic 7.4: with runs setup, then your block, then cleanup. A context manager (anything with __enter__ and __exit__, or a generator decorated with @contextlib.contextmanager) guarantees cleanup code runs, even when the body raises. with is Python's version of try/finally made reusable.

• ↔

  Multiple inheritance versus composition. Cooperative super() chains are powerful but hard to reason about. Most teams prefer one base class plus small mixins, or composition (holding other objects) over deep inheritance.

• ↔

  **__slots__ versus flexibility.** Slots save memory and catch typos, but they block dynamic attributes, complicate inheritance and pickling, and are rarely worth it unless you create very many instances.

• Done when you can write the MRO of a diamond and trace a super() chain.

• Done when you can explain __new__ versus __init__ and give two reasons to override __new__.

• Done when you can write a validating descriptor and explain why it stores values on the instance.

• Done when you can describe the GIL honestly: what it blocks, what it does not, and the options for CPU work.

• Done when you can explain reference counting, cycles and why with beats __del__.