Question 1

When would you use a list, tuple, set, or dict?

Accepted Answer

list: ordered, mutable, allows duplicates — a general sequence. tuple: ordered, immutable, hashable when its contents are — good for fixed records and dict keys. set: unordered, unique, O(1) membership — deduplication and set math. dict: key→value mapping with O(1) average lookup, insertion-ordered since 3.7. Pick by the operations you need: indexing (list/tuple), uniqueness (set), or lookup by key (dict).

Question 2

What does mutable vs immutable mean in Python?

Accepted Answer

Immutable objects (int, float, str, tuple, frozenset) cannot change in place; operations return a new object. Mutable objects (list, dict, set, bytearray) can change in place, so aliases see the change. Assignment never copies; two names can point at the same list. Only immutable (hashable) objects can be dict keys or set members. The default-argument gotcha comes from mutability: `def f(x=[])` reuses one list across calls — use None and create inside.

Question 3

What's the difference between `is` and `==`?

Accepted Answer

== compares values (uses __eq__); `is` compares identity (same object in memory, uses id()). Use `is` for singletons: None, True, False, and sentinel objects. Small ints and some strings are interned, so `a is b` can be true by CPython implementation detail — never rely on it for values. `is` is faster and cannot be overridden, which is why `x is None` is preferred over `x == None`. For containers, == is recursive by value.

Question 4

When should you use a list comprehension instead of a loop?

Accepted Answer

A comprehension builds a new collection declaratively: `[f(x) for x in xs if cond]`. They are usually faster and more readable for simple transform/filter pipelines. Available as list, set, dict, and generator (parenthesized) forms. Avoid them when logic is multi-step or has side effects — a plain loop is clearer. A generator expression `(x for x in xs)` is lazy and memory-efficient for large or streaming input.

Question 5

Explain *args and **kwargs.

Accepted Answer

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dict. In a call, * unpacks a sequence and ** unpacks a mapping into arguments. They make wrappers and decorators generic without knowing the wrapped signature. Ordering in a def: positional, *args, keyword-only, **kwargs. Keyword-only parameters (after *) force callers to name them, which improves clarity.

Question 6

How does the `with` statement work?

Accepted Answer

`with` calls __enter__ on the object and guarantees __exit__ runs even if the block raises. It is the idiomatic way to manage resources: files, locks, DB connections, transactions. __exit__ receives the exception info and can suppress it by returning True. contextlib.contextmanager turns a generator function into a context manager (code before yield is __enter__). It replaces try/finally boilerplate and makes cleanup reliable.

Question 7

Walk through try / except / else / finally.

Accepted Answer

try holds the risky code; except handles specific exception types in order. else runs only if no exception was raised — good for code that should not be guarded. finally always runs, even on return or an unhandled exception; used for cleanup. Catch the narrowest exception you can; a bare `except:` also swallows KeyboardInterrupt and hides bugs. Re-raise with `raise` (no argument) to preserve the traceback when you only wanted to log.

Question 8

Why is `range` preferred over a list of numbers?

Accepted Answer

range is a lazy, memory-constant sequence object — it computes values on demand, not up front. range supports the full slicing and membership protocol with O(1) memory. range(stop) / range(start, stop) / range(start, stop, step) cover the common loops. For iterating values use `for i in range(n)`; when you only need the items, iterate the container directly. enumerate gives index and value together, which is cleaner than manual counting.

Question 9

What are f-strings and why prefer them?

Accepted Answer

f-strings embed expressions inside string literals: f"{user.name} has {len(items)} items". They are evaluated at runtime, are concise, and are the fastest string formatting option. Format specs after a colon control presentation: f"{value:.2f}", f"{n:>8}". The `=` specifier (f"{x=}") prints the expression and its value for debugging. Prefer them over %-formatting and str.format for readability.

Question 10

How does slicing with negative indices work?

Accepted Answer

s[start:stop:step] returns a new sequence; stop is exclusive. Negative indices count from the end: s[-1] is the last element. Omitted bounds default to the start/end, so s[::-1] reverses and s[:] shallow-copies. Out-of-range slices clamp instead of raising IndexError, unlike direct indexing. Slicing a list copies references (shallow); use copy.deepcopy for nested structures.

Question 11

How do decorators work?

Accepted Answer

A decorator is a callable that takes a function and returns a replacement, applied with @ at definition time. `@deco` above `def f` is sugar for `f = deco(f)`. They wrap extra behavior — logging, timing, caching, auth — around the original function. Use functools.wraps to preserve the wrapped function's name, docstring, and metadata. Decorators with arguments are factories: the outer function returns the actual decorator.

Question 12

What is a generator and how does it differ from a normal function?

Accepted Answer

A generator function uses yield and returns a lazy iterator; calling it does not run the body. State (local variables and position) is suspended between yields, so it can produce large/infinite sequences in constant memory. next() resumes until the next yield; StopIteration signals exhaustion. Generator expressions `(x for x in xs)` are the concise form. Use them for streaming, pipelines, and to avoid building huge intermediate lists.

Question 13

What is the GIL and how does it affect concurrency?

Accepted Answer

The Global Interpreter Lock lets only one thread execute Python bytecode at a time in CPython. It makes CPU-bound multithreading ineffective for parallelism; use multiprocessing or native extensions instead. It does not block I/O: a thread releases the GIL while waiting on network, disk, or sleep, so threads still help I/O-bound work. asyncio sidesteps threads entirely with a single-threaded event loop for high-concurrency I/O. Free-threaded/no-GIL builds exist (3.13+) but are experimental and not the default.

Question 14

How does asyncio work and when is it the right tool?

Accepted Answer

asyncio runs a single-threaded event loop that multiplexes many I/O operations via coroutines (async/await). await yields control to the loop while waiting, letting other tasks run — no threads required. asyncio.gather runs awaitables concurrently; asyncio.create_task schedules one in the background. It shines for high-concurrency network I/O; it does not speed up CPU-bound code. Blocking calls (time.sleep, requests, heavy CPU) must be offloaded with run_in_executor or they stall the loop.

Question 15

How does Python resolve methods with multiple inheritance (MRO)?

Accepted Answer

Method resolution order is the linearized order in which base classes are searched, computed by the C3 algorithm. TypeError at class creation if the hierarchy is inconsistent (no valid linearization). super() follows the MRO, not just the immediate parent — critical for cooperative multiple inheritance. Inspect it with ClassName.__mro__ or ClassName.mro(). Prefer composition or mixins over deep diamond hierarchies.

Question 16

Explain closures and the late-binding loop gotcha.

Accepted Answer

A closure captures variables by reference from the enclosing scope, not their value at definition time. Lambdas/functions created in a loop all see the loop variable's final value — the classic late-binding bug. Fix it by binding the value as a default argument (`lambda x=i: …`) or with functools.partial. Closures read enclosing variables; to rebind one, declare nonlocal and, for module scope, global. Each call to the outer function creates a fresh scope, so closures over different calls are independent.

Question 17

What is a descriptor and how does @property relate to it?

Accepted Answer

A descriptor is an object defining __get__/__set__/__delete__ that customizes attribute access on a class. Functions are descriptors, which is how methods bind self. property is a built-in descriptor that maps attribute access to getter/setter/deleter methods. @property gives computed or validated attributes that look like plain fields. classmethod and staticmethod are also implemented via descriptors.

Question 18

What does __slots__ do?

Accepted Answer

__slots__ declares a fixed set of instance attributes, replacing the per-instance __dict__. It reduces memory per object and speeds up attribute access for classes with many instances. Trade-offs: you cannot add attributes outside the slot list, and multiple inheritance with non-empty slots can conflict. Properties conflict with slots of the same name. Worth it for millions of small objects; unnecessary for typical app classes.

Question 19

What's the difference between shallow and deep copy?

Accepted Answer

copy.copy / list[:] / dict() create a shallow copy: top-level is new, nested objects are shared. copy.deepcopy recursively copies nested objects, so mutating the copy cannot affect the original. Assignment (=) copies neither — it aliases the same object. deepcopy is slower and must handle cycles (it tracks memo) and uncopyable objects. Choose shallow when nested data is treated as immutable; deep when it is mutated independently.

Question 20

How does functools.lru_cache work and what are its caveats?

Accepted Answer

It memoizes a function's results keyed by the arguments, turning repeated calls into O(1) lookups. Set maxsize=None for an unbounded cache or a number for LRU eviction; typed=True separates args of different types. Arguments must be hashable — no lists or dicts. It returns the same cached object, so mutating a returned mutable result corrupts the cache. For async functions use an async-aware cache or cache the awaited value explicitly; also expose cache_clear for invalidation.

Question 21

What do dict.get, setdefault, and update do?

Accepted Answer

get(key, default) returns a default instead of raising KeyError when the key is missing. setdefault(key, default) returns the existing value or inserts the default and returns it. update merges another mapping in place, overwriting existing keys. `key in dict` is the idiomatic membership test; d[key] raises when absent. dict is insertion-ordered, so iteration order is insertion order.

Question 22

How do split, join, and strip work?

Accepted Answer

split(sep) returns a list of substrings; str.split() with no args splits on any whitespace and drops empties. join is the inverse: sep.join(list) builds a string from an iterable of strings. strip/lstrip/rstrip remove leading/trailing whitespace or given characters (not substrings). Strings are immutable, so these return new strings. replace returns a new string and takes an optional count.

Question 23

How does tuple unpacking work, including starred and swap?

Accepted Answer

a, b = (1, 2) assigns by position and raises if the count mismatches. a, *rest = [1,2,3] collects remaining items into a list. Swapping is a, b = b, a — the right side is evaluated first into a tuple. It also works in for loops and function arguments/unpacking. The number of targets must match unless you use a starred target.

Question 24

What are enumerate and zip used for?

Accepted Answer

enumerate(iterable, start=0) yields (index, value) pairs, avoiding manual counters. zip(*iterables) yields tuples of aligned items and stops at the shortest input. zip is lazy in Python 3 and can be reversed with zip(*pairs). Both return iterators, so wrap in list() when you need a list. itertools.zip_longest fills missing values instead of stopping early.

Question 25

When is a lambda useful, and how do you sort with a key?

Accepted Answer

A lambda is a single-expression anonymous function; it can't contain statements. The common use is a short key or callback, e.g. sorted(items, key=lambda x: x.age). sorted and list.sort accept a key function and a reverse flag. Use operator.itemgetter/attrgetter instead of a lambda when you need speed or clarity. Name a real function with def when the logic is more than a trivial expression.

Question 26

How do any and all work, and why pair them with generators?

Accepted Answer

any is True if at least one item is truthy; all is True only if every item is truthy. Both short-circuit, so they stop at the first decisive value. Passing a generator avoids building an intermediate list. all([]) is True and any([]) is False (vacuous truth). They are the idiomatic replacement for a loop with a boolean flag.

Question 27

What is falsy in Python?

Accepted Answer

Falsy values: None, False, 0, 0.0, 0j, '' (empty string), and empty containers ([], {}, set(), ()). Everything else is truthy, including the string '0' and a non-empty list. Custom classes can define __bool__ or __len__ to control truthiness. Prefer explicit checks like `if x is not None` when None is distinct from other falsy values.

Question 28

Explain positional, keyword, and keyword-only arguments.

Accepted Answer

Positional arguments are matched left to right; keyword arguments are matched by name. Arguments after * are keyword-only; before / are positional-only. A call can mix positional then keyword, but not the other way around. Default values are evaluated once at definition time (the mutable-default gotcha). Keyword arguments make call sites readable and order-independent.

Question 29

Explain Python's LEGB scope rule and nonlocal/global.

Accepted Answer

Names resolve Local -> Enclosing -> Global -> Built-in. Assignment inside a function makes a name local unless declared global or nonlocal. nonlocal rebinds a name in the nearest enclosing function scope; global targets module scope. Reading an enclosing variable is fine without a declaration; rebinding it is not. UnboundLocalError happens when you assign to a name before reading it locally.

Question 30

What are the import styles and what does `if __name__ == '__main__'` do?

Accepted Answer

import module, from module import name, and import module as alias are the three styles. Importing a module runs it once and caches it in sys.modules. The __name__ guard runs a block only when the file is executed directly, not when imported. Circular imports are a sign of tangled dependencies and can raise ImportError. Relative imports (from . import x) work only inside a package.

Question 31

What is a metaclass and when would you use one?

Accepted Answer

A metaclass is the class of a class; type is the default, so classes are instances of their metaclass. It can intercept class creation via __new__/__init__ to register classes, enforce rules, or inject methods. Use it sparingly — most needs are met by inheritance, __init_subclass__, or decorators. ABCMeta is the built-in example, powering abstractmethod enforcement. metaclass=... in a class definition sets it.

Question 32

How do abstract base classes work?

Accepted Answer

Subclass abc.ABC and decorate methods with @abstractmethod to require implementations. Instantiating a subclass that misses an abstract method raises TypeError. ABCs can also be used as virtual base classes via register(). They document and enforce an interface without the strictness of Java. Protocols (typing.Protocol) offer structural typing as an alternative.

Question 33

What does @dataclass generate, and what are its pitfalls?

Accepted Answer

__init__, __repr__, and __eq__ are generated from the fields. field(default_factory=list) avoids the shared-mutable-default bug. frozen=True makes instances immutable and hashable; slots=True saves memory. Ordering requires order=True; comparison is field order. Default values are evaluated once, so mutable defaults need default_factory.

Question 34

How do generator send/throw/close work?

Accepted Answer

gen.send(value) resumes the generator and makes value the result of the paused yield. The first send must be None (or use next()) to run up to the first yield. gen.throw(exc) raises inside the generator at the yield point. gen.close() raises GeneratorExit inside the generator, running finally blocks. This is the basis of coroutine-like pipelines before async/await.

Question 35

What are async generators and async comprehensions?

Accepted Answer

An async generator uses `async def` with `yield` and is consumed with `async for`. They combine streaming with awaiting I/O per item — good for paginated APIs and websockets. Async comprehensions use async for and optionally await inside. They must run inside an event loop (not a plain for loop). anext() and aclose() are the async analogs of next() and close().

Question 36

How does CPython allocate memory for small and large objects?

Accepted Answer

CPython uses a private allocator with arenas of 256 KB split into pools and 512-byte blocks. Objects of 512 bytes or less go through pymalloc; larger ones use malloc directly. Reference counting frees objects immediately; a cyclic GC handles reference cycles. Small ints (-5 to 256) are cached, and interned strings/identifiers are shared. id() exposes the address, which is why it differs between equal-but-distinct objects.

Question 37

What is monkey patching and why is it risky?

Accepted Answer

Monkey patching replaces attributes or methods at runtime on a module or class. It is used by test mocks and libraries like gevent, but action-at-a-distance is hard to debug. Patching a method on a class changes it for every instance and caller. Prefer dependency injection or subclassing; confine patching to tests with unittest.mock.patch. Patching a module doesn't update references already imported elsewhere.

Question 38

What is singledispatch used for?

Accepted Answer

functools.singledispatch turns a function into a generic function that dispatches on the type of the first argument. Register implementations with @fn.register(SomeType). It is a clean alternative to isinstance chains and keeps behavior near its type. The base implementation is the fallback when no registered type matches. Use functools.singledispatchmethod for methods.

Question 39

What are the useful contextlib tools?

Accepted Answer

contextmanager turns a generator into a context manager (before yield is __enter__, after is __exit__). suppress swallows listed exceptions for a block. ExitStack manages a dynamic set of context managers and callbacks. nullcontext is a no-op context manager useful in conditional code. closing ensures .close() is called on an object.

Question 40

When do you pick threads, processes, or asyncio?

Accepted Answer

I/O-bound work: threads or asyncio (asyncio for many concurrent sockets). CPU-bound work: multiprocessing (or native extensions), because the GIL serializes bytecode. Threads are simpler for blocking libraries that have no async client. asyncio needs an async ecosystem; mixing blocking calls stalls the loop. Processes have higher memory/startup cost and require pickled data between them.