Python Fundamentals and Core Syntax Questions

Comprehensive knowledge of core Python language features and syntax, including primitive and composite data types such as integer numbers, floating point numbers, strings, booleans, lists, dictionaries, sets, and tuples. Candidates should understand variable assignment and naming, operators for arithmetic, logical, and comparison operations, and control flow constructs including conditional statements and loops. Expect familiarity with function definition, invocation, parameter passing, return values, and scope rules, as well as common built in functions and idioms such as iteration utilities, list comprehensions, generator expressions, and basic functional utilities like map and filter. Candidates should demonstrate error and exception handling techniques and best practices for writing readable and maintainable code with modularization and clear naming. Practical skills include file input and output, working with common data formats such as comma separated values and JavaScript Object Notation, selecting appropriate data structures with attention to performance and memory characteristics, and applying memory efficient patterns for processing large data sets using iterators and generators. Familiarity with the standard library and common utilities for parsing and transforming data, and the ability to write small code snippets to solve algorithmic and data manipulation tasks, are expected.

MediumTechnical

66 practiced

You must compute the top-k most frequent tokens from a text corpus that is too large to fit into memory (single machine). Describe and implement a memory-efficient Python approach (use standard library) that streams the file and returns top-k token-frequency pairs. Discuss trade-offs and how to handle very large vocabularies.

Sample Answer

Approach (brief): stream the corpus once and hash-partition tokens into N temporary files on disk (so each partition fits memory). Then process each partition in-memory using collections.Counter to get its local top-k, and finally merge local top-k lists with a min-heap to produce the global top-k. This uses only Python stdlib and trades disk I/O for low RAM.

python

import os
import tempfile
import hashlib
import heapq
from collections import Counter

def top_k_streaming(filepath, k, partitions=64, tokenize=None):
    # Simple whitespace tokenizer unless provided
    tokenize = tokenize or (lambda line: line.strip().split())

    # Create temp files for partitions
    tmp_dir = tempfile.mkdtemp(prefix="topk_parts_")
    part_paths = [os.path.join(tmp_dir, f"part_{i}.txt") for i in range(partitions)]
    part_files = [open(p, "w", encoding="utf8") for p in part_paths]

    # Partitioning pass: stream file, write token per line to a partition file
    with open(filepath, "r", encoding="utf8", errors="ignore") as f:
        for line in f:
            for tok in tokenize(line):
                h = int(hashlib.md5(tok.encode("utf8")).hexdigest(), 16)
                part_files[h % partitions].write(tok + "\n")

    for pf in part_files:
        pf.close()

    # For each partition, count tokens and get local top-k
    global_heap = []  # min-heap of (count, token)
    for p in part_paths:
        with open(p, "r", encoding="utf8", errors="ignore") as pf:
            cnt = Counter(map(str.rstrip, pf))  # counts tokens in partition
        # get top-k in this partition
        for token, c in cnt.items():
            if len(global_heap) < k:
                heapq.heappush(global_heap, (c, token))
            else:
                if c > global_heap[0][0]:
                    heapq.heapreplace(global_heap, (c, token))
        os.remove(p)

    os.rmdir(tmp_dir)

    # return sorted top-k descending
    return sorted(global_heap, key=lambda x: -x[0])

Key points and reasoning:- Partitioning ensures each partition’s vocabulary fits in memory; counting per partition is exact.- Using hashlib.md5 gives deterministic partitioning (avoids randomized built-in hash).- Final merge uses an O(V_local log k) heap approach; V_local is unique tokens per partition.

Complexity:- Time: O(T + sum(V_i log k)) where T is total tokens streamed, V_i unique tokens per partition.- Disk: O(T) for temporary token writes (can be reduced by writing token IDs if mapping allowed).- Memory: bounded by largest partition's vocabulary size + O(k).

Edge cases and trade-offs:- I/O-heavy: choose partitions to balance RAM vs disk I/O; more partitions -> smaller memory but more files and seeks.- Skew: heavy-hitter tokens concentrate in same partition — fine (counts still exact) but may make that partition large; you can use second-level partitioning or increase partitions.- Alternatives: approximate structures (Count–Min Sketch, HyperLogLog) reduce disk but provide approximate counts; not in stdlib.- Tokenization: adapt to your NLP pipeline (lowercasing, stemming, BPE) before partitioning to reduce vocabulary size.

HardTechnical

58 practiced

Create a small utility in Python that safely evaluates a simple arithmetic expression received as a string (numbers, +, -, *, /, parentheses) without using eval(). The evaluator should reject names, attributes, function calls, and other Python constructs. Provide the implementation and explain your parsing strategy (tokenization or ast parsing).

Sample Answer

Approach: I use Python's ast module to parse the expression into an AST, then recursively validate and evaluate only a minimal safe subset of nodes: numeric constants, binary ops (+, -, *, /), unary +/-, and parentheses (represented in AST). Any other node (Name, Call, Attribute, comprehension, etc.) is rejected, preventing code injection. This is safer than eval() and simpler than writing a full tokenizer/parser.

python

import ast
import operator

# mapping AST operator nodes to Python functions
_BINOPS = {
    ast.Add: operator.add,
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
}

_UNARYOPS = {
    ast.UAdd: operator.pos,
    ast.USub: operator.neg,
}

def safe_eval(expr: str):
    """
    Safely evaluate a simple arithmetic expression containing only
    numbers, +, -, *, / and parentheses. Raises ValueError on invalid input.
    """
    try:
        node = ast.parse(expr, mode='eval')
    except SyntaxError as e:
        raise ValueError(f"Syntax error: {e}") from None

    def _eval(node):
        if isinstance(node, ast.Expression):
            return _eval(node.body)
        if isinstance(node, ast.Constant):  # Python 3.8+
            if isinstance(node.value, (int, float)):
                return node.value
            raise ValueError("Only int/float constants are allowed")
        if isinstance(node, ast.BinOp):
            op_type = type(node.op)
            if op_type not in _BINOPS:
                raise ValueError(f"Operator {op_type} not allowed")
            left = _eval(node.left)
            right = _eval(node.right)
            try:
                return _BINOPS[op_type](left, right)
            except ZeroDivisionError:
                raise ValueError("Division by zero")
        if isinstance(node, ast.UnaryOp):
            op_type = type(node.op)
            if op_type not in _UNARYOPS:
                raise ValueError(f"Unary operator {op_type} not allowed")
            operand = _eval(node.operand)
            return _UNARYOPS[op_type](operand)
        # Reject everything else: Name, Call, Attribute, Subscript, etc.
        raise ValueError(f"Disallowed expression: {type(node).__name__}")

    return _eval(node)

Key points:- Validation and evaluation are done in one AST traversal.- Complexity: O(n) time and O(h) recursion stack (h = AST depth).- Edge cases: rejects names/calls/attributes; catches syntax errors and division by zero.- Example: safe_eval("2*(3+4)-5/2") -> 11.5

Alternatives: writing a hand-rolled tokenizer+parser (more work but more control) or using a parser generator. Using ast keeps code concise and secure when node allowance is strict.

HardTechnical

76 practiced

Implement a simple Bloom filter class in Python that supports add(item) and probably_contains(item), with configurable size and number of hash functions. Explain how false positive rate depends on parameters and show example calculations for choosing size when expecting 1M items with 1% false positive rate.

Sample Answer

Approach: implement a Bloom filter with a bit array of m bits and k independent hash functions (we derive k from double-hashing using two base hashes). add sets k bits; probably_contains checks them. Use formulas to choose m and k for target false positive rate p given expected n inserts.

python

import hashlib
import math

class BloomFilter:
    def __init__(self, m, k):
        self.m = m                  # number of bits
        self.k = k                  # number of hash functions
        self.bits = bytearray((m + 7) // 8)

    def _hashes(self, item):
        b = item if isinstance(item, bytes) else str(item).encode()
        h1 = int(hashlib.md5(b).hexdigest(), 16)
        h2 = int(hashlib.sha1(b).hexdigest(), 16)
        for i in range(self.k):
            yield (h1 + i * h2) % self.m

    def add(self, item):
        for pos in self._hashes(item):
            self.bits[pos // 8] |= 1 << (pos % 8)

    def probably_contains(self, item):
        return all((self.bits[pos // 8] >> (pos % 8)) & 1 for pos in self._hashes(item))

Key concepts:- False positive probability p ≈ (1 - e^{-k n / m})^k.- Optimal k ≈ (m / n) * ln 2, minimizing p for given m,n.

Choosing parameters (example): expect n = 1,000,000, target p = 0.01.- m = - (n * ln p) / (ln 2)^2 ≈ -1e6 * ln(0.01) / 0.4809 ≈ 9.57e6 bits (~1.2 MB).- k = (m / n) * ln 2 ≈ 6.64 → use k = 7 hash functions.

Complexity:- add and probably_contains: O(k) time, O(m) space.Edge cases:- Underestimating n increases false positives.- Use good hash functions; avoid correlated hashes. Consider resizing or counting Bloom filters for deletions.

MediumTechnical

80 practiced

Implement a Python decorator retry(max_attempts=3, backoff_factor=0.5) that retries a function on exceptions with exponential backoff. The decorator should be usable with and without arguments, preserve function metadata (name, docstring), and allow specifying which exception types to catch. Provide example usage for a flaky network call.

Sample Answer

Approach: implement a decorator factory that supports both @retry and @retry(...) by detecting if called with a function. Use functools.wraps to preserve metadata. Retry on specified exception types with exponential backoff: sleep = backoff_factor * (2 ** (attempt-1)). Raise last exception if all attempts fail.

python

import time
import functools
from typing import Callable, Tuple, Type

def retry(func: Callable = None, *, max_attempts: int = 3, backoff_factor: float = 0.5, exceptions: Tuple[Type[BaseException], ...] = (Exception,)):
    """
    Retry decorator usable as:
      @retry
      @retry()
      @retry(max_attempts=5, backoff_factor=1, exceptions=(ConnectionError,))
    """
    def decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(1, max_attempts + 1):
                try:
                    return f(*args, **kwargs)
                except exceptions as e:
                    last_exc = e
                    if attempt == max_attempts:
                        break
                    sleep = backoff_factor * (2 ** (attempt - 1))
                    time.sleep(sleep)
            raise last_exc
        return wrapper

    # If used without args: @retry
    if callable(func):
        return decorator(func)
    # Used with args: @retry(...)
    return decorator

Key points:- preserves __name__ and __doc__ via functools.wraps- supports both usages by checking if first arg is callable- exceptions parameter restricts which errors trigger retries- exponential backoff formula shown

Time/space: no extra space beyond call stack; time increases due to sleeps (sum of backoffs). Edge cases:- max_attempts < 1: treat as immediate raise (validate if needed)- backoff_factor 0 -> tight retries- ensure exceptions tuple provided (single type allowed too)

Example usage (flaky network call):

python

import requests

@retry(max_attempts=4, backoff_factor=0.5, exceptions=(requests.RequestException,))
def fetch(url):
    resp = requests.get(url, timeout=2)
    resp.raise_for_status()
    return resp.text

MediumTechnical

75 practiced

Write pytest unit tests for a function normalize_text(s: str) -> str that should perform: trimming, collapse multiple whitespace to single spaces, lowercasing, and removing non-ASCII control characters. Provide tests for normal cases, edge cases (empty string, very long input), and malicious input (long sequence of whitespace). Show how to parametrize tests and run them.

Sample Answer

Approach: create parametrized unit tests covering normal transformations, edge cases (empty, very long), and malicious inputs (very long whitespace, lots of control chars). Assume function is implemented in text_utils.py as normalize_text(s: str) -> str.

python

# tests/test_normalize_text.py
import pytest
from text_utils import normalize_text

@pytest.mark.parametrize(
    "input_str, expected",
    [
        ("  Hello   World  ", "hello world"),                     # trimming + collapse + lower
        ("\tMixed\tCASE\nand  spaces  ", "mixed case and spaces"),# tabs/newlines -> spaces
        ("NoChange", "nochange"),                                 # simple lowercase
        ("control\x00chars\x1fhere", "controlcharshere"),         # remove non-ASCII control chars
        ("  Multiple \u00A0nbsp\u00A0 spaces ", "multiple nbsp spaces"), # NBSP treated as space collapse
    ]
)
def test_normal_cases(input_str, expected):
    assert normalize_text(input_str) == expected

def test_empty_string():
    assert normalize_text("") == ""

def test_only_whitespace():
    # any whitespace-only input collapses to empty string after trimming
    assert normalize_text("    \t\n  ") == ""

def test_very_long_input():
    # create a very long input ~1e6 chars to ensure performance/memory behavior
    chunk = "  Foo   Bar " * 100000  # ~1.1M chars
    out = normalize_text(chunk)
    # expected should be "foo bar" repeated (single space, trimmed)
    assert out.startswith("foo bar")
    assert "  " not in out  # no double spaces
    assert out.count("foo") == 100000

def test_malicious_long_whitespace():
    long_ws = "A" + (" " * 200_000) + "B"
    out = normalize_text(long_ws)
    assert out == "a b"

How to run:- Run all tests: pytest -q- Run specific file: pytest -q tests/test_normalize_text.py- Run single test: pytest -q tests/test_normalize_text.py::test_very_long_input

Key points:- Parametrization keeps tests concise and readable.- Large-input tests check performance and memory behavior without asserting exact full strings (use properties).- Malicious whitespace tests ensure the function safely collapses long runs of spaces.

Unlock Full Question Bank

Get access to hundreds of Python Fundamentals and Core Syntax interview questions and detailed answers.

Join thousands of developers preparing for their dream job.