Python Interview Questions — What Senior Engineers Need to Know

The Global Interpreter Lock (GIL) is a mutex inside CPython that ensures only one thread executes Python bytecode at any given moment.

Both ThreadPoolExecutor and ProcessPoolExecutor are part of Python's concurrent.futures module and provide a high-level interface for running callables asynchronously using a pool of workers.

A decorator in Python is a callable -- typically a function -- that takes a function as an argument and returns a new callable.

A generator in Python is a special type of iterator.

A context manager is an object that defines a setup and teardown protocol for a block of code, ensuring cleanup happens reliably regardless of whether the block exits normally or via an exception.

LEGB is Python's name resolution order: when the interpreter encounters a variable name, it searches scopes in this sequence: Local → Enclosing → Global → Built-in.

Python's Method Resolution Order (MRO) determines which class's method is called when a name is looked up in an inheritance hierarchy.

Python's `@property` decorator turns a method into a descriptor that's accessed like an attribute — `obj.name` instead of `obj.name()`.

By default, every Python instance stores its attributes in a per-instance dictionary (`__dict__`).

These three decorators are distinct tools that change how a method receives arguments and how it is invoked — understanding them requires understanding Python's descriptor protocol.

In Python, `is` and `==` are fundamentally different operations that are often confused because they coincidentally produce the same result in common cases.

In Python, default argument values are evaluated **once** when the `def` statement is executed — not each time the function is called.

Copying in Python has three distinct levels: assignment, shallow copy, and deep copy.

Object creation in Python is a two-step process mediated by `__new__` and `__init__`.

CPython uses two complementary mechanisms for memory management: **reference counting** as the primary strategy and a **cyclic garbage collector** as a fallback for cyclic references that reference counting cannot handle.

A decorator is a function that takes a function and returns a modified function.

`__getattribute__` and `__getattr__` are both attribute access hooks, but they differ fundamentally in when they are called and how dangerous they are to override.

`functools.partial` is a higher-order function that creates a new callable with some arguments of an existing function pre-filled (partially applied).

`defaultdict` and `OrderedDict` are both subclasses of `dict` in `collections`, each adding a specialized behavior on top of the standard dictionary.

Duck typing is a programming style where an object's suitability for a use is determined by the presence of the required methods and attributes, not by its class hierarchy.

Monkey patching is the practice of dynamically modifying or replacing attributes, methods, or modules at runtime — without altering the original source code.

A mixin is a class that provides specific, reusable behavior intended to be 'mixed in' to other classes via multiple inheritance, without being instantiated directly or expressing an 'is-a' relationship.

Profiling is the process of measuring where a program spends its time, so you can direct optimization efforts at the actual bottleneck rather than guessing.

The itertools module provides building blocks for efficient looping in Python, operating lazily so they never materialize full sequences in memory.

**Fixtures** are functions decorated with `@pytest.fixture` that pytest injects into test functions by parameter name.

**Code coverage** quantifies how much of your source code is exercised by a test suite.

**PyPI** (Python Package Index) is the public registry of Python packages.

A **module** in Python is any single `.py` file.