Python Fundamentals and Problem Solving Questions

Comprehensive knowledge of the Python programming language, idiomatic usage, and the ability to implement correct, readable, and testable solutions to coding problems. Core language elements include syntax and semantics, primitive and composite data types such as integers, floats, strings, lists, dictionaries, sets, and tuples, sequence and mapping operations, control flow constructs, functions and closures, and object oriented programming basics including classes, instances, inheritance, and special methods. Additional practical topics include error and exception handling, file input and output operations, comprehensions and generator expressions, generator functions and iteration protocols, context managers, lambda functions, unpacking, and common standard library utilities. Candidates should understand algorithmic time and space complexity for common operations, typical performance characteristics of lists and dictionaries, and common pitfalls such as mutable default arguments and shared mutable state. Interview focused expectations include writing clean correct code without editor assistance, sensible variable naming, implementing basic algorithms and data structure manipulations under time constraints, reasoning about tradeoffs and complexity, and demonstrating testability and code quality.

MediumTechnical

58 practiced

Implement an LRUCache class in Python with methods get(key) and put(key, value) that both run in O(1) time. The cache should support a fixed capacity and evict the least-recently-used item when full. Implement it using only the standard library (collections.OrderedDict or a custom doubly-linked list + dict). Explain how an ML pipeline might use this to cache preprocessed feature vectors and avoid repeated computation.

Sample Answer

A common O(1) approach is to combine a hashmap for key→node lookup with an order structure to track recency. Python’s collections.OrderedDict already supports moving items to the end on access, so we can build a concise, correct LRU.

python

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int):
        assert capacity > 0
        self.capacity = capacity
        self.cache = OrderedDict()  # key -> value; order: least recent -> most recent

    def get(self, key: int):
        if key not in self.cache:
            return -1
        # mark as most recently used
        value = self.cache.pop(key)
        self.cache[key] = value
        return value

    def put(self, key: int, value: int):
        if key in self.cache:
            # update existing and mark most recent
            self.cache.pop(key)
        elif len(self.cache) >= self.capacity:
            # evict least recently used (first item)
            self.cache.popitem(last=False)
        self.cache[key] = value

Key points:- OrderedDict.pop and popitem are O(1); get/put both O(1) average.- Space: O(capacity).- Edge cases: capacity <= 0 (asserted), overwriting existing keys, repeated gets update recency, large values impact memory.

Alternative: implement explicit doubly-linked list + dict for environments without OrderedDict.

ML pipeline usage:- Preprocessing or feature extraction (e.g., embeddings, tokenized sequences, normalized features) can be expensive. Wrap computed feature vectors in an LRUCache keyed by a deterministic input ID or hash (e.g., file path + preprocessing params). During training/serving, repeated requests for the same item hit the cache and return preprocessed vectors instantly, reducing CPU/GPU preprocessing and I/O. Use capacity sized to available memory and evict least-recent items to keep hot data (recently used or batched examples) resident. Include cache invalidation when preprocessing code or parameters change (bump the cache key namespace).

MediumTechnical

59 practiced

Given a list of dictionaries representing dataset rows, implement stratified_split(rows, label_key, train_frac, val_frac, test_frac, seed) in Python that splits the rows into train/val/test lists stratified by label_key and reproducible using the seed. Handle labels with very few samples and document your chosen behavior (e.g., minimum samples per split or assignment policy).

Sample Answer

Approach: group rows by label, shuffle each group deterministically with seed, then split each group according to fractions. For labels with very few samples I apply a simple deterministic fallback: if group size >=3 use floor/ceil to try to give at least one sample to each requested split proportionally; if size==2 assign 1→train, 1→val; if size==1 assign to train. This preserves stratification as much as possible while being deterministic.

python

import math
from collections import defaultdict
from random import Random
from typing import List, Dict, Tuple

def stratified_split(rows: List[Dict],
                     label_key: str,
                     train_frac: float,
                     val_frac: float,
                     test_frac: float,
                     seed: int = 0) -> Tuple[List[Dict], List[Dict], List[Dict]]:
    """
    Stratified split of rows (list of dicts) by label_key into train/val/test.
    - Fractions must sum to 1.0 (or close).
    - Reproducible via seed.
    - Behavior for small groups:
      * n >= 3: allocate counts = round(n * frac) with adjustments to sum to n and ensure at least 1 for splits with >0 frac where possible.
      * n == 2: train gets 1, val gets 1 (test 0) unless test_frac >> val_frac; simple deterministic rule used.
      * n == 1: assigned to train (prefer training set for model stability).
    """
    eps = 1e-6
    if abs(train_frac + val_frac + test_frac - 1.0) > eps:
        raise ValueError("Fractions must sum to 1.0")

    rng = Random(seed)
    groups = defaultdict(list)
    for r in rows:
        groups[r[label_key]].append(r)

    train, val, test = [], [], []

    for label, items in groups.items():
        n = len(items)
        rng.shuffle(items)

        if n == 1:
            train.extend(items)
            continue
        if n == 2:
            # deterministic small-group policy: favor train then val
            train.append(items[0])
            val.append(items[1])
            continue

        # For n >= 3, compute initial counts, then adjust to sum to n
        t = int(math.floor(n * train_frac))
        v = int(math.floor(n * val_frac))
        te = int(math.floor(n * test_frac))
        # distribute remaining by largest fractional remainder
        rem = n - (t + v + te)
        remainders = [
            ((n * train_frac) - t, 't'),
            ((n * val_frac) - v, 'v'),
            ((n * test_frac) - te, 'te'),
        ]
        remainders.sort(reverse=True)
        idx = 0
        while rem > 0:
            if remainders[idx][1] == 't':
                t += 1
            elif remainders[idx][1] == 'v':
                v += 1
            else:
                te += 1
            idx = (idx + 1) % 3
            rem -= 1

        # Ensure that splits with non-zero target fraction get at least 1 when possible
        if train_frac > 0 and t == 0:
            t += 1
            # steal from largest other split
            if v >= te and v > 1:
                v -= 1
            elif te > 1:
                te -= 1
        if val_frac > 0 and v == 0 and n >= 2:
            v += 1
            if t > 1:
                t -= 1
            elif te > 1:
                te -= 1
        if test_frac > 0 and te == 0 and n >= 3:
            te += 1
            if t > 1:
                t -= 1
            elif v > 1:
                v -= 1

        # perform the slice
        i = 0
        train.extend(items[i:i+t]); i += t
        val.extend(items[i:i+v]); i += v
        test.extend(items[i:i+te])

    return train, val, test

Key points:- Deterministic per-seed via Random(seed).- Keeps stratification by splitting each label group separately.- Small-group policy: 1→train, 2→train+val; for >=3 use proportional allocation with remainder tie-breaking.Complexity: O(n) time, O(n) space. Edge cases: empty rows list, labels missing label_key (KeyError), fractions not summing to 1. Adjust policy if you prefer different small-group handling (e.g., prefer val/test).

MediumTechnical

45 practiced

Write a Python generator function flatten(iterable) that takes a nested iterable of arbitrary depth (for example: [1, [2, 3], (4, [5, [6]])]) and yields scalar elements lazily without building the flattened list in memory. The function should treat str and bytes as atomic elements (not to be flattened). Provide tests demonstrating the generator behavior.

Sample Answer

To flatten nested iterables lazily, use a recursive generator that yields scalar items and iterates into sub-iterables except for atomic types (str, bytes). Avoid checking collections.abc.Iterable directly on strings—explicitly treat str/bytes as atomic. Use a stack or recursion; recursion is simpler and preserves lazy behavior.

python

from collections.abc import Iterable

def flatten(iterable):
    """
    Lazily yield scalar elements from a nested iterable of arbitrary depth.
    Treat str and bytes as atomic (do not iterate into them).
    """
    # Strings and bytes are atomic
    if isinstance(iterable, (str, bytes)):
        yield iterable
        return

    # If it's not iterable (e.g., int, float, None), yield it
    if not isinstance(iterable, Iterable):
        yield iterable
        return

    # It's an iterable (list, tuple, set, generator, etc.)
    for item in iterable:
        if isinstance(item, (str, bytes)):
            yield item
        elif isinstance(item, Iterable):
            # Recurse into nested iterable
            for sub in flatten(item):
                yield sub
        else:
            yield item

Key points:- Recursion yields lazily; we never build a flattened list.- We explicitly treat str and bytes as atomic.- Works for generators, lists, tuples, sets, etc.

Time complexity: O(n) to visit all elements. Space complexity: O(d) recursion depth on call stack (d = nesting depth).

Tests (demonstrating behavior and laziness):

python

def test_flatten_basic():
    nested = [1, [2, 3], (4, [5, [6]]), "abc", b"bytes"]
    assert list(flatten(nested)) == [1,2,3,4,5,6,"abc", b"bytes"]

def test_flatten_generator_and_lazy():
    def gen():
        yield 1
        yield [2, (3,)]
        yield 4
    f = flatten(gen())
    assert next(f) == 1
    assert next(f) == 2
    # consume remaining
    assert list(f) == [3,4]

def test_flatten_atomic_strings():
    nested = [["a","b"], ("c", ["d", ["e"]])]
    assert list(flatten(nested)) == ["a","b","c","d","e"]

# Run tests
if __name__ == "__main__":
    test_flatten_basic()
    test_flatten_generator_and_lazy()
    test_flatten_atomic_strings()
    print("All tests passed.")

Edge cases:- Infinite iterables: still lazy; consumer controls termination.- Custom iterables: must implement Iterable.- Very deep nesting may hit recursion limits; consider iterative stack for extreme depth.

EasyTechnical

47 practiced

Describe the purpose and differences between __init__, __repr__, and __str__ methods in Python classes. Provide a concise example of a lightweight ModelWrapper class for an ML model that implements these methods to aid debugging and readable logging in production environments.

Sample Answer

__init__, __repr__, and __str__ serve different purposes:

- __init__(self, ...): initializer/constructor. Sets up instance state (weights, hyperparams, file paths). Not a return value.- __repr__(self): unambiguous representation intended for developers and debugging. Should ideally be a valid Python expression to recreate the object or at least contain all key state. Used by repr(), debugger, logs.- __str__(self): readable/string representation for end-users or logs. Friendly, concise. Called by str() and print().

Example lightweight ModelWrapper:

python

class ModelWrapper:
    def __init__(self, model_name: str, framework: str, version: str, params: dict = None):
        # Initialize minimal metadata (avoid serializing heavy model objects here)
        self.model_name = model_name
        self.framework = framework
        self.version = version
        self.params = params or {}

    def __repr__(self):
        # Developer-focused: include enough info to identify and (optionally) reconstruct
        return (f"ModelWrapper(model_name={self.model_name!r}, framework={self.framework!r}, "
                f"version={self.version!r}, params={self.params!r})")

    def __str__(self):
        # Human-friendly: concise single-line summary for logs
        return f"{self.model_name} ({self.framework} v{self.version}) params={len(self.params)}"

Key notes:- Keep __init__ side-effect free (avoid heavy loads); lazy-load large models.- __repr__ should aid debugging and testing; __str__ should help readable production logs.- Use !r for repr-safe fields and keep sensitive info out of representations.

MediumTechnical

48 practiced

Compare Python's built-in list, collections.deque, and array.array for queue-like operations commonly used in ML data pipelines (append/pop from both ends). Discuss performance characteristics (amortized bounds), memory usage, and when to prefer each. Propose a simple micro-benchmark to compare them for your expected workload.

Sample Answer

Short answer:- list: good for append/pop at end (amortized O(1)), slow O(n) for pop(0) or insert(0); compact memory per element (object pointers); good when queue mostly uses the tail.- collections.deque: O(1) amortized for append/appendleft/pop/popleft; implemented as a doubly-linked block buffer, slightly higher per-item overhead than list but far faster for both-end ops and predictable latency; ideal for ML data pipelines with streaming, batching, and worker queues.- array.array: stores C-type primitives densely (no Python object pointers), so lower memory and faster numeric element throughput; append/pop from end O(1); no efficient pop(0) (costly O(n) because it shifts elements). Use when queuing raw numeric buffers and memory/serialization matters.

Performance and memory:- list: append/pop() amortized O(1); pop(0) O(n). Memory: array of PyObject* with overallocation growth factor (~1.125–1.125x), lower per-element overhead than deque but higher than array.array for primitives.- deque: all-end ops O(1) amortized with small constant; memory: segmented blocks -> more overhead but avoids large reallocs.- array.array: end ops O(1); memory minimal for primitives; shifting expensive.

When to prefer:- deque: streaming pipelines, worker queues, sliding windows.- list: simple stacks or when only pushing/popping at one end; when random access matters.- array.array: large numerical buffers, batched numeric data, and tight memory constraints.

Micro-benchmark (example):

python

import time, random, array
from collections import deque

def bench(container_factory, ops=10_000_00):
    c = container_factory()
    start = time.perf_counter()
    for i in range(ops):
        c.append(i)
    for i in range(ops):
        c.popleft() if hasattr(c,'popleft') else (c.pop(0) if isinstance(c,list) else c.pop(0))
    return time.perf_counter()-start

print("list", bench(lambda: []))
print("deque", bench(lambda: deque()))
print("array", bench(lambda: array.array('i')))

Benchmark tips: use realistic item types (ints vs objects), vary batch sizes, measure throughput under multithreaded producers/consumers, check memory with tracemalloc or psutil.

Unlock Full Question Bank

Get access to hundreds of Python Fundamentals and Problem Solving interview questions and detailed answers.

Join thousands of developers preparing for their dream job.