Python Programming and Libraries Questions

Practical knowledge of the Python programming language and commonly used data science libraries. Expect assessment of idiomatic syntax, core data structures, and libraries such as NumPy and Pandas for efficient array and table operations. Candidates should demonstrate writing clear, maintainable, and testable code using list comprehensions, generators, vectorized operations, and proper memory use. Topics include debugging and profiling workflows, performance optimization techniques, packaging and dependency management, basic concurrency and asynchronous patterns, unit testing, and reproducible development practices.

HardTechnical

93 practiced

Implement a thread-safe LRU cache decorator in Python without using functools.lru_cache (you may use threading primitives). The decorator should accept a maxsize and be safe for concurrent access by multiple threads. Discuss complexity and potential contention points.

Sample Answer

**Approach**: implement LRU with a dict for storage and a doubly-linked list for order; use threading.RLock for concurrency. Decorator returns wrapper that locks around lookups and updates, minimizing lock hold time.

**Implementation**:

python

import threading
from functools import wraps

def lru_cache(maxsize=128):
    def deco(func):
        cache = {}
        head = tail = None
        lock = threading.RLock()
        class Node:
            __slots__=('key','val','prev','next')
            def __init__(self,k,v):
                self.key=k;self.val=v;self.prev=self.next=None
        def _move_to_front(node):
            nonlocal head, tail
            # unlink then insert at head (omitted for brevity)
        @wraps(func)
        def wrapper(*args, **kwargs):
            key=(args,tuple(sorted(kwargs.items())))
            with lock:
                node=cache.get(key)
                if node:
                    _move_to_front(node); return node.val
            val=func(*args, **kwargs)
            with lock:
                if key in cache: return cache[key].val
                node=Node(key,val); cache[key]=node; _move_to_front(node)
                if len(cache)>maxsize:
                    # remove tail
                    pass
            return val
        return wrapper
    return deco

**Complexity**: O(1) average get/set.

**Contention**: global lock serializes cache access; reduce by using read-mostly optimistic check (check without lock then confirm under lock) or use shard locks (multiple caches by hash) to reduce contention.

MediumTechnical

80 practiced

Implement a function top_k_frequent(iterable, k) that returns the k most frequent items and their counts. Your solution must handle very large iterables (possibly streaming) and have O(n) expected time with O(k) additional memory where possible. Use Python.

Sample Answer

**Goal**: return k most frequent items from a possibly streaming iterable using O(k) extra memory where possible.

**Approach**: Use Misra-Gries (frequent algorithm) for streaming approximate top-k with O(k) memory; for exact top-k when feasible, use counting with a hashmap and a min-heap of size k (memory O(u) where u unique). For very large universes, prefer Misra-Gries.

**Misra-Gries implementation (approximate, deterministic guarantees)**:

python

from collections import defaultdict

def top_k_frequent(stream, k):
    if k < 1:
        return []
    counters = {}
    for x in stream:
        if x in counters:
            counters[x] += 1
        elif len(counters) < k:
            counters[x] = 1
        else:
            # decrement all
            to_del = []
            for y in list(counters):
                counters[y] -= 1
                if counters[y] == 0:
                    del counters[y]
    # counters are candidates; to get actual counts, re-scan
    true_counts = defaultdict(int)
    for x in stream:
        if x in counters:
            true_counts[x] += 1
    return sorted(true_counts.items(), key=lambda t: -t[1])[:k]

**Notes**: The algorithm uses O(k) memory and one or two passes (approximate single-pass; exact requires second pass over data or storing counts). Choose Misra-Gries for streaming huge data; use Counter+heap for exact counts when unique items fit memory.

EasyTechnical

93 practiced

Given a NumPy array a of shape (N, M), write Python code to compute a boolean mask of rows that contain any NaN using vectorized NumPy operations. Do not use Python loops.

Sample Answer

**Vectorized mask for rows containing any NaN:**

python

import numpy as np

# a is shape (N, M)
mask = np.isnan(a).any(axis=1)

**Explanation:**- np.isnan(a) produces boolean array shape (N, M).- .any(axis=1) reduces per row to True if any element is NaN.

This is fully vectorized, memory-efficient (single boolean array) and avoids Python loops. For very large arrays consider processing in chunks to limit peak memory.

MediumTechnical

144 practiced

Explain how vectorized operations in NumPy and Pandas can be faster than explicit Python loops. Describe one situation where vectorization might be slower and why.

MediumTechnical

97 practiced

A data pipeline intermittently produces different results on different runs (non-deterministic). List possible Python-language and library causes (e.g., dict ordering, floating-point reductions, parallelism) and propose concrete fixes to achieve determinism for production runs.

Unlock Full Question Bank

Get access to hundreds of Python Programming and Libraries interview questions and detailed answers.

Join thousands of developers preparing for their dream job.