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.

EasyTechnical

82 practiced

Explain Python function parameter types: positional, keyword, default values, *args, and **kwargs. Provide a function signature example that demonstrates each kind, and describe typical usage patterns in data processing pipelines.

Sample Answer

Positional parameters: parameters matched by order. Use when arguments are required and order is natural.Keyword parameters: passed as name=value; improve readability and allow out-of-order calls.Default values: provide defaults in signature so parameter becomes optional.*args: collects extra positional arguments as a tuple.**kwargs: collects extra keyword arguments as a dict.

Example combining all:

python

def process_batch(data, transform, *, normalize=True, batch_size=100, **kwargs):
    """
    data: positional (required) - dataset or iterator
    transform: positional (required) - function applied to each item
    * (bare asterisk) forces following params to be keywords
    normalize, batch_size: keyword params with default values
    **kwargs: extra options like 'shuffle=True' or 'num_workers=4'
    """
    # Implementation omitted
    pass

Notes and typical usage in data pipelines:- Positional for essential inputs (data, transform).- Keyword + defaults for tunable hyperparameters (batch_size, normalize) so callers change only what they need.- Use **kwargs to accept backend-specific options (e.g., shuffle, prefetch, device) without changing API.- Avoid overusing *args; prefer explicit params for clarity in production pipelines.- Validate and pop known keys from kwargs to maintain robustness and clear errors.

HardTechnical

60 practiced

Implement a JSON validator in Python using only the standard library that validates each input JSON object against a simple schema like: {'id': int, 'name': str, 'tags': list}. The validator should yield human-readable path-specific error messages (e.g., 'user.address.zip: expected int, got str').

Sample Answer

Approach: recursively walk the JSON Python object against a schema that can contain Python types, nested dict schemas, or list schemas (a single-item list describing element type/schema). Collect path-specific, human-readable errors and yield them.

python

import json
from typing import Any, Dict, Iterable

def validate(obj: Any, schema: Any, path: str = "") -> Iterable[str]:
    """
    Recursively validate obj against schema.
    schema can be:
      - a Python type (int, str, bool, float)
      - a dict mapping keys -> subschema (for objects)
      - a single-element list [subschema] meaning a list whose items match subschema
    Yields error strings like 'user.address.zip: expected int, got str'
    """
    if isinstance(schema, type):
        if not isinstance(obj, schema):
            yield f"{path or '<root>'}: expected {schema.__name__}, got {type(obj).__name__}"
        return

    if isinstance(schema, dict):
        if not isinstance(obj, dict):
            yield f"{path or '<root>'}: expected object, got {type(obj).__name__}"
            return
        for key, subschema in schema.items():
            if key not in obj:
                yield f"{(path + '.' if path else '') + key}: missing required field"
            else:
                new_path = (path + "." if path else "") + key
                yield from validate(obj[key], subschema, new_path)
        return

    if isinstance(schema, list):
        if len(schema) != 1:
            raise ValueError("List schema must have exactly one element describing the item schema")
        item_schema = schema[0]
        if not isinstance(obj, list):
            yield f"{path or '<root>'}: expected array, got {type(obj).__name__}"
            return
        for idx, item in enumerate(obj):
            new_path = f"{path}[{idx}]" if path else f"[{idx}]"
            yield from validate(item, item_schema, new_path)
        return

    raise TypeError("Unsupported schema type: " + repr(schema))

# Example usage:
schema = {"id": int, "name": str, "tags": [str], "profile": {"age": int}}
data = json.loads('{"id": "12", "name": "Alice", "tags": ["x", 2], "profile": {"age": "30"}}')
print(list(validate(data, schema)))

Key points:- Recursive descent supports nested objects and arrays.- Errors include precise paths (object.key or array[index]) for easy debugging.- Uses only stdlib (json, typing).Time complexity: O(n) where n is total nodes in JSON (each node visited once). Space: O(d) stack for recursion depth d.Edge cases: schema lists must be single-element descriptors; missing keys reported; doesn't auto-coerce types. Alternatives: support optional fields (e.g., schema value set to (type, 'optional')) or union types (tuple of types) if needed.

HardTechnical

61 practiced

Implement a robust CSV reader in Python that handles varying column counts per row, different delimiters, quoted fields, and malformed lines. The reader should yield a dict per row keyed by header names when a header exists and report parsing errors with line numbers without crashing the whole pipeline.

Sample Answer

Approach:- Use Python's csv module (robust, handles quoting) while detecting delimiter with csv.Sniffer when not provided.- Read file line-by-line to track line numbers and catch malformed rows (e.g., wrong field count) without stopping the pipeline.- Yield a dict per row keyed by header names (if present) or column indices when header absent.- Provide an errors list and optional error_handler callback to surface parsing issues with line numbers.

Code implementation:

python

import csv
from typing import IO, Iterator, Dict, Optional, Callable, Tuple, List

class CSVParseError(Exception):
    def __init__(self, lineno: int, message: str, row: Optional[List[str]] = None):
        super().__init__(f"Line {lineno}: {message}")
        self.lineno = lineno
        self.message = message
        self.row = row

def robust_csv_reader(
    fh: IO[str],
    delimiter: Optional[str] = None,
    has_header: Optional[bool] = None,
    skip_blank_lines: bool = True,
    error_handler: Optional[Callable[[CSVParseError], None]] = None
) -> Iterator[Tuple[int, Dict[str, str]]]:
    """
    Yields (line_number, row_dict). Collects parsing errors via error_handler or continues.
    - fh: file-like object opened in text mode.
    - delimiter: if None, try to sniff.
    - has_header: if None, attempt to detect (uses Sniffer).
    """
    sample = fh.read(8192)
    fh.seek(0)
    if delimiter is None:
        try:
            dialect = csv.Sniffer().sniff(sample)
            delimiter = dialect.delimiter
        except Exception:
            delimiter = ','

    if has_header is None:
        try:
            has_header = csv.Sniffer().has_header(sample)
        except Exception:
            has_header = True

    reader = csv.reader(fh, delimiter=delimiter)
    errors: List[CSVParseError] = []

    # Helper to report errors
    def report(err: CSVParseError):
        errors.append(err)
        if error_handler:
            try:
                error_handler(err)
            except Exception:
                pass  # don't let handler break the pipeline

    # Read header
    try:
        first_row = next(reader)
    except StopIteration:
        return  # empty file

    lineno = 1
    if skip_blank_lines and len(first_row) == 0:
        # consume until non-empty or EOF
        while len(first_row) == 0:
            try:
                first_row = next(reader); lineno += 1
            except StopIteration:
                return

    if has_header:
        headers = [h.strip() if h is not None else '' for h in first_row]
    else:
        # treat first row as data; create numeric headers
        headers = [f"col_{i}" for i in range(len(first_row))]
        # yield the first row as data below by rewinding via an iterator that yields it first
        def row_iter():
            yield first_row
            yield from reader
        reader = row_iter()

    # Main loop
    for row in reader:
        lineno += 1
        if skip_blank_lines and len(row) == 0:
            continue
        # If row has different number of columns, report error but attempt to map as best as possible
        if len(row) != len(headers):
            msg = f"Expected {len(headers)} fields, got {len(row)}"
            err = CSVParseError(lineno, msg, row)
            report(err)
            # strategy: pad with empty strings or truncate
            if len(row) < len(headers):
                row = row + [''] * (len(headers) - len(row))
            else:
                row = row[:len(headers)]
        # Build dict
        row_dict = {headers[i]: row[i] for i in range(len(headers))}
        yield lineno, row_dict

    # attach errors to generator consumer if needed (not typical), otherwise user-supplied handler collects them
    # Optionally return errors list via attribute (can't on generator), so caller should use error_handler or capture externally.

Key concepts / reasoning:- csv.Sniffer infers delimiter and header presence for varied inputs.- We do not crash on malformed lines; instead we create CSVParseError with line number and continue after best-effort normalization (pad/truncate).- Optional error_handler callback lets the pipeline log, increment metrics, or persist errors asynchronously.

Time & space complexity:- Time: O(N * M) where N = number of rows, M = avg fields processed (linear scan).- Space: O(1) extra (streaming); only errors list grows if you collect them.

Edge cases:- Inconsistent quoting or newlines inside quoted fields: csv.reader handles standard CSV quoting; non-conformant quoting will raise — catch via error_handler by wrapping reader iteration if desired.- Extremely large fields: streaming avoids full-file memory use.- Files with multiple delimiter types per line: Sniffer chooses one; for mixed-delimiter files pre-cleaning is required.

Alternative approaches:- Use pandas.read_csv with error_bad_lines=False and on_bad_lines callback (convenient but heavier memory/dep).- Pre-parse lines with regex for nonstandard formats before csv.reader.

Example usage:- Provide an error_handler that logs to a monitoring system; iterate generator to process rows into a dataframe or downstream feature pipeline.

MediumTechnical

83 practiced

Explain Python scoping rules (LEGB: Local, Enclosing, Global, Built-in). Provide a concrete example showing a closure capturing a loop variable incorrectly when creating functions in a loop, and demonstrate two ways to fix the problem.

Sample Answer

Python follows the LEGB scoping rule: lookup happens in this order:- Local: names defined in the current function.- Enclosing: names in any enclosing (non-global) function scopes (useful for closures).- Global: module-level names.- Built-in: names in the builtins module.

Common pitfall: closures capturing a loop variable. Example (incorrect):

python

funcs = []
for i in range(3):
    def f():
        return i
    funcs.append(f)

print([fn() for fn in funcs])  # prints [2, 2, 2], not [0,1,2]

Why: each f closes over the same name i; by the time functions run, i == 2.

Two fixes:

1) Bind current value as a default argument (captures value at definition time):

python

funcs = []
for i in range(3):
    def f(i=i):
        return i
    funcs.append(f)

print([fn() for fn in funcs])  # [0, 1, 2]

2) Use a factory / explicit closure capturing a parameter:

python

def make_f(x):
    def f():
        return x
    return f

funcs = [make_f(i) for i in range(3)]
print([fn() for fn in funcs])  # [0, 1, 2]

Notes:- default-arg trick is concise and common in data code (e.g., callbacks).- factory approach is clearer about intent and works well when more setup is needed.- Use nonlocal when you need to mutate an enclosing variable inside a nested function.

MediumTechnical

79 practiced

Write Python code to normalize and clean a column of free-form text values: lowercasing, trimming whitespace, removing punctuation, and collapsing multiple spaces. The function should accept an iterator of strings and yield cleaned strings lazily so it can be used in streaming pipelines.

Sample Answer

Approach: implement a lazy generator that processes each input string with a consistent pipeline: coerce to str, normalize unicode, trim, lowercase, remove punctuation (including Unicode punctuation via Unicode character categories), collapse multiple spaces, and yield the cleaned line. Precompile regexes and build an ASCII translate table for speed.

python

import re
import unicodedata
import string

# Precompile regexes once
_MULTI_SPACE_RE = re.compile(r"\s+")
_LEADING_TRAILING_SPACE_RE = re.compile(r"^\s+|\s+$")

# Build translation table for ASCII punctuation (fast path)
_ASCII_PUNCT_TRANS = str.maketrans({c: None for c in string.punctuation})

def _remove_unicode_punctuation(s: str) -> str:
    """
    Remove characters whose Unicode category starts with 'P' (punctuation).
    Keeps performance reasonable by only scanning if non-ASCII punctuation may exist.
    """
    # Quick path: if all chars are ASCII, use translate
    if all(ord(ch) < 128 for ch in s):
        return s.translate(_ASCII_PUNCT_TRANS)
    # Otherwise, build a list skipping punctuation categories
    return "".join(ch for ch in s if not unicodedata.category(ch).startswith("P"))

def clean_text_stream(strings):
    """
    Generator that lazily yields cleaned strings.

    Steps per item:
    - Skip None by yielding empty string (or decide to continue)
    - Cast to str, normalize using NFKC (compatibility)
    - Trim leading/trailing whitespace
    - Lowercase
    - Remove punctuation (ASCII + Unicode)
    - Collapse multiple whitespace to single space

    Usage:
      for cleaned in clean_text_stream(iterator_of_strings):
          ...
    """
    for item in strings:
        if item is None:
            yield ""
            continue
        s = str(item)
        # Normalize unicode (optional but helps with composed/decomposed forms)
        s = unicodedata.normalize("NFKC", s)
        # Trim
        s = _LEADING_TRAILING_SPACE_RE.sub("", s)
        # Lowercase
        s = s.lower()
        # Remove punctuation
        s = _remove_unicode_punctuation(s)
        # Collapse any whitespace (tabs, newlines) to single space
        s = _MULTI_SPACE_RE.sub(" ", s)
        yield s

Key points:- Lazy: uses generator so memory is O(1) per item.- Handles Unicode punctuation via unicodedata.category.- Precompiles regexes and translation table for speed.

Time complexity: O(total_chars) across the stream (each character inspected a constant number of times). Space complexity: O(1) extra memory (per-item output string proportional to input item length).

Edge cases:- None values handled (yields empty string) — adjust behavior if you prefer skipping.- Preserves digits and underscores (if you want to remove underscores, add them to the translate table).- Very long strings will still allocate cleaned string per item; for extreme sizes consider streaming chunk processors.

Alternatives:- Use the third-party regex module with \p{P} to remove punctuation with one call.- Use nltk/spacy/tokenization if you need linguistically-aware normalization (stemming, stop-word removal).

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.