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

55 practiced

Implement a Python generator `merge_sorted(a, b)` that merges two sorted iterators of integers into a single sorted iterator without converting iterators to lists. Explain how this approach is useful for merging sorted partitions during a reduce step in a distributed pipeline.

Sample Answer

To merge two sorted iterators without converting to lists, we can consume them lazily and always yield the smaller next element. We keep the current "peek" value for each iterator by advancing only when we yield, which keeps memory O(1) and enables streaming merges suitable for large partitions in a distributed reduce step.

python

def merge_sorted(a, b):
    """
    Merge two sorted integer iterators a and b into a single sorted iterator.
    Works lazily without materializing inputs.
    """
    a = iter(a)
    b = iter(b)

    try:
        na = next(a)  # peek next from a
    except StopIteration:
        na = None

    try:
        nb = next(b)  # peek next from b
    except StopIteration:
        nb = None

    while na is not None or nb is not None:
        if nb is None or (na is not None and na <= nb):
            yield na
            try:
                na = next(a)
            except StopIteration:
                na = None
        else:
            yield nb
            try:
                nb = next(b)
            except StopIteration:
                nb = None

Why this is useful in a distributed reduce step:- Memory-efficient: streams merged results without loading partitions into RAM.- Backpressure-friendly: downstream consumers can pull at their own rate.- Simple to parallelize: each reducer can merge many sorted partition streams pairwise or with a k-way heap.Complexity: O(n+m) time, O(1) extra space. Edge cases: empty iterators, duplicate values (keeps both, stable by <=).

MediumTechnical

51 practiced

Write a Python decorator `retry` that retries a function call when it raises an exception, with parameters `retries`, `initial_delay`, and `backoff_factor`. The decorator should be usable on any function and should not swallow the final exception. Show example usage and explain blocking vs non-blocking behavior.

Sample Answer

To implement retry with exponential backoff, wrap the function in a decorator that retries on exceptions up to retries times, sleeping between attempts using initial_delay * backoff_factor**attempt. Re-raise the last exception if all retries fail so callers can handle it.

python

import time
import functools
from typing import Callable

def retry(retries: int = 3, initial_delay: float = 1.0, backoff_factor: float = 2.0):
    """
    Retry decorator with exponential backoff.
    - retries: number of retry attempts (total attempts = retries + 1)
    - initial_delay: delay before first retry in seconds
    - backoff_factor: multiplier applied to delay after each failure
    """
    def decorator(func: Callable):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempt = 0
            delay = initial_delay
            while True:
                try:
                    return func(*args, **kwargs)
                except Exception as exc:
                    if attempt >= retries:
                        # don't swallow final exception
                        raise
                    # optional: log the failure here
                    time.sleep(delay)  # blocking wait
                    attempt += 1
                    delay *= backoff_factor
        return wrapper
    return decorator

Example usage:

python

@retry(retries=4, initial_delay=0.5, backoff_factor=2)
def fetch_remote():
    # simulate network call that may fail
    ...

Key points:- Total attempts = retries + 1. Final exception is re-raised.- Blocking vs non-blocking: above uses time.sleep (blocking), pausing the current thread—simple and fine for standalone scripts or worker processes. For non-blocking (e.g., async event loop or high-concurrency systems), use an async version with asyncio.sleep and support async functions:

python

import asyncio
def async_retry(...):
    def decorator(f):
        async def wrapper(*a, **k):
            ...
            await asyncio.sleep(delay)

- Edge cases: zero retries, negative inputs (validate), functions with side effects (idempotency concerns), specific exception filtering (only retry on certain exceptions), and jitter to avoid thundering herd.- Best practice: add logging, metrics, and optionally max_delay cap and jitter for production data pipelines.

MediumTechnical

48 practiced

Explain the difference between shallow and deep copy in Python. Give examples using nested lists and custom objects, show how to create deep copies using the `copy` module, and explain scenarios where `copy.copy()` is insufficient in ETL transformations.

Sample Answer

Shallow vs deep copy in Python:- Shallow copy creates a new outer object but references the same nested objects. Deep copy recursively copies all nested objects so modifications to the copy don’t affect the original.

Example with nested lists:

python

import copy

original = [[1,2], [3,4]]
shallow = list(original)        # or copy.copy(original)
deep = copy.deepcopy(original)

shallow[0].append(99)
print(original)  # [[1,2,99], [3,4]] -> changed because inner lists shared
print(deep)      # [[1,2], [3,4]] -> unaffected

Example with custom objects:

python

class Row:
    def __init__(self, data):
        self.data = data

orig = [Row({'id':1}), Row({'id':2})]
sh = copy.copy(orig)
dp = copy.deepcopy(orig)

sh[0].data['id'] = 10
print(orig[0].data['id'])  # 10 -> shallow shares Row instances
print(dp[0].data['id'])    # 1  -> deep copy isolated

Using copy module:- copy.copy(obj) => shallow copy- copy.deepcopy(obj) => deep copy (handles nested structures, tries to preserve object graphs)

Why copy.copy() is insufficient in ETL:- ETL often manipulates nested records, metadata, or schema objects. Shallow copies will share references to nested dicts/lists (e.g., column metadata, nested JSON fields), causing accidental mutation of the source dataset or pipeline-wide state, leading to data corruption, duplicated transformations, or hard-to-find bugs.- Also, shared mutable caches or connection objects may be unintentionally modified.

Best practices for Data Engineers:- Use deepcopy when you need an independent copy of nested/mutable data structures.- For large objects, deepcopy can be expensive — consider: - Creating fresh objects via serialization/deserialization (json/pickle) when schema-compatible, - Designing immutable data flows (avoid in-place mutation), - Copy only the fields needed (selective shallow + manual clone of nested parts).

EasyTechnical

43 practiced

Implement a Python function `unique_preserve_order(items: Iterable[T]) -> List[T]` that returns unique elements preserving their first-seen order. The implementation should be efficient and work for hashable elements. Describe complexity and how to extend it to unhashable elements (e.g., dicts).

Sample Answer

A simple, efficient approach for hashable items is to iterate once, track seen items in a set, and append unseen items to the result list. This is O(n) time and O(n) additional space.

python

from typing import Iterable, List, TypeVar

T = TypeVar("T")

def unique_preserve_order(items: Iterable[T]) -> List[T]:
    """Return items with duplicates removed, preserving first-seen order.
    Works for hashable elements in O(n) time."""
    seen = set()
    result = []
    for x in items:
        if x not in seen:
            seen.add(x)
            result.append(x)
    return result

Key points:- Time complexity: O(n) average (set membership and add are O(1) average).- Space complexity: O(n) for the seen set and result list.- Handles empty input and any iterable.

Extending to unhashable elements (e.g., dicts):- Option 1: Derive a stable, hashable representation (tuple of items, or json.dumps with sort_keys=True) and track those keys in the set.- Option 2: Use a list for seen and linear scan (O(n^2) worst-case) if inputs are small.- Option 3 (practical): For complex but comparable objects, compute a key via a user-supplied key function that returns a hashable fingerprint.

Example for dicts using tuple-of-items:

python

def unique_dicts(items: Iterable[dict]) -> List[dict]:
    seen = set()
    result = []
    for d in items:
        key = tuple(sorted(d.items()))
        if key not in seen:
            seen.add(key)
            result.append(d)
    return result

This keeps O(n) average time assuming key construction is O(k) per element (k = dict size). Choose the fingerprint method carefully to avoid collisions and to reflect the intended notion of equality.

MediumTechnical

50 practiced

Explain the difference between `zip` and `itertools.zip_longest`. Describe a memory-efficient strategy to process three large files line-by-line in lockstep, accounting for missing lines in shorter files and aligning fields with padding where necessary.

Sample Answer

zip (built-in) stops when the shortest input iterable is exhausted; it pairs items index-by-index but truncates to the shortest length. itertools.zip_longest continues until the longest iterable is exhausted and fills missing values from shorter iterables with a specified fillvalue.

Memory-efficient strategy (streaming, line-by-line, pad fields):- Open all three files and iterate their file objects (which are lazy generators) so you never load whole files into memory.- Use itertools.zip_longest(files..., fillvalue=None) to get tuples of corresponding lines; when a file is shorter you receive None (or chosen fillvalue).- For aligning fields within each line (e.g., CSV fields), split each non-None line, then use itertools.zip_longest on those field lists with a pad token ('' or a sentinel) to align columns.

Example:

python

from itertools import zip_longest

pad_line = ''      # when a whole line is missing
pad_field = ''     # when a field within a line is missing

with open('a.txt') as fa, open('b.txt') as fb, open('c.txt') as fc, open('out.txt','w') as fo:
    for la, lb, lc in zip_longest(fa, fb, fc, fillvalue=None):
        # strip newline and handle missing lines
        rows = [(s.rstrip('\n') if s is not None else pad_line).split(',') for s in (la, lb, lc)]
        # align fields per row
        aligned = list(zip_longest(*rows, fillvalue=pad_field))
        # write one output row per aligned field position (example: join fields with '|')
        for cols in aligned:
            fo.write('|'.join(cols) + '\n')

Notes and best practices:- Use binary/text buffering where appropriate and avoid read(). Use csv.reader/writer for robust CSV handling (handles quoting).- Choose sensible fillvalues and document semantics (e.g., None vs empty string).- If files are extremely large and IO-bound, ensure proper buffering, consider gzip.open for compressed inputs, and profile I/O.

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.