Question 1

Write a function to check whether two strings are anagrams of each other. What is the optimal time complexity?

Accepted Answer

Sorting both strings and comparing is O(n log n). Using Counter or a character frequency array is O(n) and is the preferred approach. The solution must handle case sensitivity and spaces consistently or the comparison will silently give wrong answers.

Question 2

What is the difference between *args and **kwargs, and when would you use each?

Accepted Answer

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dict. Use *args when the number of positional inputs is unknown, **kwargs when callers should be able to pass named options without modifying the function signature.

Question 3

What is a context manager and how does the with statement work?

Accepted Answer

A context manager is any object that implements __enter__ and __exit__. The with statement calls __enter__ on entry and __exit__ on exit — guaranteed, even if an exception is raised. This makes with the idiomatic way to manage resources like files, locks, and database transactions without leaking them.

Question 4

What is the most Pythonic way to count word frequencies in a string, and what does Counter return for missing keys?

Accepted Answer

collections.Counter is the standard tool: it accepts any iterable and returns a dict-like object with counts. For a missing key it returns 0 rather than raising KeyError, which makes downstream arithmetic safe without extra guards.

Question 5

How do you define and raise custom exceptions in Python?

Accepted Answer

Subclass Exception (not BaseException) to create a custom exception. Give it a clear name, optionally store structured data in __init__, and place it in a dedicated exceptions module. Raise it with raise and catch it with except, narrowing to your specific type before broader ones.

Question 6

What does `@dataclass` give you over a plain class, and what are its main configuration options?

Accepted Answer

`@dataclass` auto-generates `__init__`, `__repr__`, and `__eq__` from the field annotations declared in the class body, eliminating boilerplate. Key options include `frozen=True` for immutability and automatic `__hash__`, `order=True` for comparison operators, and `slots=True` (Python 3.10+) for memory-efficient slot-based storage.

Question 7

How do you use dict comprehensions effectively, and what are common patterns in data work?

Accepted Answer

A dict comprehension uses the syntax `{key_expr: value_expr for item in iterable if condition}` to build a dictionary in one expression. It is faster than calling `dict()` on a list of pairs and more readable than a for-loop with repeated `d[k] = v` assignments. Common data patterns include inverting a dict, grouping values, and transforming keys or values in bulk.

Question 8

When and how do you use enumerate() and zip() in Python, and what are common mistakes when using them together?

Accepted Answer

enumerate() pairs each element with its index without maintaining a manual counter. zip() pairs elements from multiple iterables together. Both return lazy iterators, so they compose efficiently. The key trap with zip() is silent truncation when iterables differ in length.

Question 9

Write a function that returns all duplicate values in a list. What is the optimal time complexity?

Accepted Answer

The optimal solution is O(n) using a set to track seen elements and a second set to collect duplicates, avoiding any nested iteration. A Counter-based approach is equally O(n) and often more readable.

Question 10

What does it mean for functions to be first-class objects in Python?

Accepted Answer

First-class functions can be stored in variables, passed as arguments, returned from other functions, and placed in data structures — just like any other object. This is the foundation for higher-order functions, decorators, callbacks, and functional programming patterns in Python.

Question 11

How do you flatten a nested list in Python, and how does the approach differ for one level deep versus arbitrarily deep nesting?

Accepted Answer

For a single level of nesting, a list comprehension or itertools.chain.from_iterable is idiomatic and O(n). For arbitrary depth, recursion or an explicit stack is required. The right choice depends on whether the structure is known at write time.

Question 12

How do you group a list of items by a property using defaultdict, and when would you use it over a plain dict?

Accepted Answer

collections.defaultdict eliminates the boilerplate of checking whether a key exists before appending, making grouping logic cleaner and less error-prone. It runs in O(n) and is the standard pattern before reaching for itertools.groupby or pandas groupby.

Question 13

What is the difference between an instance method, a class method, and a static method in Python?

Accepted Answer

Instance methods receive the instance as the first argument (`self`) and can read and modify instance state. Class methods receive the class as the first argument (`cls`) via `@classmethod` and are used for alternative constructors or class-level operations. Static methods receive no implicit argument and are plain functions namespaced inside a class.

Question 14

What is the difference between `is` and `==` in Python, and when does `is` give a surprising result?

Accepted Answer

`==` calls `__eq__` and tests value equality. `is` tests object identity — whether two names point to the exact same object in memory. The surprise comes from CPython's interning: small integers (-5 to 256) and many short strings are cached, so `is` returns True even for separately created objects, but this is an implementation detail you must never rely on.

Question 15

When should you use lambda, map, filter, and reduce — and when should you avoid them?

Accepted Answer

lambda, map, and filter are concise for simple one-liners passed to higher-order functions, but list/generator comprehensions are usually more readable. reduce belongs in functools and is best reserved for cases where the fold operation is non-trivial; an explicit loop is often clearer.

Question 16

How do list, dict, and set comprehensions work in Python, and when should you avoid them?

Accepted Answer

Comprehensions are syntactic sugar for building a new collection by iterating over an iterable and optionally filtering elements. They are faster than equivalent for-loops because the iteration runs at the C level inside the interpreter. Avoid them when the expression is too complex to read at a glance — a plain loop with descriptive variable names is preferable.

Question 17

Are list comprehensions faster than equivalent for-loops in Python, and when should you prefer a generator expression instead?

Accepted Answer

List comprehensions are typically 20–50% faster than equivalent for-loops with list.append() because the bytecode is optimised and the attribute lookup for append is avoided. Generator expressions use O(1) memory versus O(n) for a comprehension, so prefer them when you only iterate once.

Question 18

Given a new data problem, how do you decide whether to use a list, dict, or set?

Accepted Answer

Choose a list when order matters and you need indexed access or duplicates. Choose a dict when you need to map keys to values and look up by key in O(1). Choose a set when you need uniqueness, fast membership testing, or set-algebra operations. Getting this choice wrong usually means either incorrect results (keeping duplicates when you needed uniqueness) or avoidable O(n) lookups.

Question 19

How does Python list slicing work, including step and negative indices?

Accepted Answer

Slicing uses the syntax `seq[start:stop:step]` and returns a new list containing elements from index `start` up to but not including `stop`, stepping by `step`. Negative indices count from the end; a negative step reverses direction. Omitted parts default to the beginning, end, or step of 1.

Question 20

When would you use a Python list versus a NumPy array, and what are the performance trade-offs?

Accepted Answer

Python lists are heterogeneous, pointer-based, and general-purpose. NumPy arrays are homogeneous, stored as contiguous typed memory, and support vectorised operations that run at C speed. For numerical work on more than a few hundred elements, NumPy is almost always faster and more memory-efficient.

Question 21

What is the difference between a list and a tuple, and when should you use each?

Accepted Answer

Lists are mutable sequences; tuples are immutable. Use a tuple when the collection of items is fixed by meaning — coordinates, RGB values, function return values — and a list when the collection will grow, shrink, or be modified in place. Immutability also makes tuples hashable, so they can serve as dict keys or set members.

Question 22

Implement Fibonacci with memoization in Python. What problem does memoization solve, and what is the time complexity before and after?

Accepted Answer

Naive recursive Fibonacci is O(2^n) because it recomputes the same subproblems exponentially. Memoization caches results of subproblems, reducing time to O(n) with O(n) space. Python's functools.lru_cache makes this a one-line decorator.

Question 23

Which Python built-in types are mutable and which are immutable, and why does it matter?

Accepted Answer

Immutable types — int, float, bool, str, bytes, tuple, frozenset — cannot be changed after creation; operations return new objects. Mutable types — list, dict, set, bytearray — can be changed in place. Mutability determines hashability (only immutables can be dict keys/set members), function side-effect behaviour, and thread-safety considerations.

Question 24

What is the difference between class attributes and instance attributes in Python, and why are mutable class attributes dangerous?

Accepted Answer

Class attributes are defined on the class object and shared by all instances; instance attributes are defined on the individual instance and shadow any class attribute of the same name. A mutable class attribute (such as a list or dict) is shared across all instances, so mutating it via one instance mutates it for every other instance — a common and silent bug.

Question 25

What is the mutable default argument trap in Python, and how do you fix it?

Accepted Answer

Default argument values are evaluated once when the function is defined, not each time it is called. If the default is a mutable object like a list or dict, all calls that use the default share the same object — so mutations in one call persist into the next. The fix is to use None as the default and create the mutable object inside the function body.

Question 26

What is the difference between positional and keyword arguments in Python?

Accepted Answer

Positional arguments are matched by their position in the call; keyword arguments are matched by name and can appear in any order. Python 3 also introduced positional-only (/) and keyword-only (*) separators to enforce calling conventions in function signatures.

Question 27

How does the `@property` decorator work in Python, and when should you prefer it over a plain attribute?

Accepted Answer

`@property` turns a method into a descriptor that Python calls automatically on attribute access, letting you add validation or computation behind a dot-access interface without changing callers. Use it when a value is derived, needs guarding, or must be lazily computed — not as a default for every attribute.

Question 28

What are .pyc files and what role does Python bytecode play?

Accepted Answer

When Python imports a module, it compiles the source to platform-independent bytecode and caches it in a .pyc file inside __pycache__. On subsequent imports the cached bytecode is loaded directly if the source is unchanged, skipping the parse-and-compile step. Bytecode is not machine code — it is still interpreted by the CPython virtual machine.

Question 29

In Python, do variables store values or references to objects?

Accepted Answer

Python variables are names — they store references (pointers) to objects, not the objects themselves. Assignment binds a name to an object; it never copies the object. Understanding this explains why mutating an object through one name is visible through all other names that reference the same object.

Question 30

Write Python to read a CSV file line by line and compute a column aggregate without loading the entire file into memory.

Accepted Answer

Using the csv module with a generator or a running accumulator keeps memory use constant — O(1) space — regardless of file size. This matters when files are larger than available RAM, a common situation in data engineering pipelines.

Question 31

How do you reverse a list and remove duplicates in Python, and what are the performance implications of each approach?

Accepted Answer

Reversing a list is O(n) whether you use slice notation or list.reverse(). Deduplication is O(n) with a set conversion but O(n²) if you check membership against a list. Understanding when order must be preserved changes which tool to reach for.

Question 32

What set operations does Python support, and where are they practically useful in data work?

Accepted Answer

Python sets support union, intersection, difference, and symmetric difference as both operators and methods, all running in O(min(m,n)) to O(m+n) time. They are useful for deduplication, membership testing in large collections, and computing overlaps between datasets — operations that would be expensive with lists.

Question 33

How do you sort a list of dictionaries by a specific key in Python, and what is the difference between sorted() and list.sort()?

Accepted Answer

Use sorted() with a key= lambda to produce a new sorted list, or list.sort() to sort in place. Both use Timsort and run in O(n log n). sorted() works on any iterable and returns a new list; list.sort() operates in place and returns None.

Question 34

What is the difference between `__str__` and `__repr__` in Python, and which should you implement first?

Accepted Answer

`__repr__` is the developer-facing representation — unambiguous, ideally eval-able back to the object. `__str__` is the user-facing string — readable and concise. When only `__repr__` is defined, Python falls back to it for `str()` as well, so implement `__repr__` first.

Question 35

Solve the Two Sum problem. Given a list of integers and a target, return the indices of the two numbers that add up to the target. What is the optimal complexity?

Accepted Answer

The hashmap approach solves Two Sum in O(n) time and O(n) space by storing each number's index as you iterate and checking whether the complement has already been seen. A brute-force nested loop is O(n²) and unnecessary.

Question 36

Why do Python projects use virtual environments, and what are the modern tools for dependency management?

Accepted Answer

A virtual environment is an isolated Python installation with its own site-packages, preventing version conflicts between projects sharing the same machine. Modern tooling has moved from pip-plus-requirements.txt toward lock-file-based tools: pip-tools, Poetry, and uv, which pin exact transitive dependency versions for reproducible installs.

Question 37

Why is NumPy significantly faster than Python for-loops for numerical computation, and what is vectorization?

Accepted Answer

NumPy operations execute compiled C code over contiguous memory blocks in a single call, while a Python loop incurs interpreter overhead and dynamic type checks on every element. Vectorization means expressing an operation over an entire array at once so the hot path never re-enters the Python interpreter.

Question 38

Why are Python strings immutable, and how does string interning affect memory?

Accepted Answer

Strings are immutable so they can be safely shared (interned), used as dict keys, and passed across threads without locks. Every operation that looks like mutation — slicing, concatenation, `.replace()` — returns a new string object. Interning means CPython may store only one copy of a string literal and reuse it, saving memory for repeated identifiers and short strings.

Question 39

What are Abstract Base Classes in Python, how do you define them, and how do they relate to duck typing?

Accepted Answer

Abstract Base Classes (ABCs) from the `abc` module let you declare interfaces with `@abstractmethod` — any concrete subclass that does not implement all abstract methods raises `TypeError` at instantiation. ABCs coexist with duck typing: you can register unrelated classes as virtual subclasses without inheritance, and `isinstance` checks will pass.

Question 40

What is a closure in Python, and what problem does it solve?

Accepted Answer

A closure is a function that retains access to variables from its enclosing scope even after that scope has finished executing. It is the mechanism behind decorators, factory functions, and stateful callbacks without needing a class.

Question 41

When should you use composition instead of inheritance in Python, and what are the design signals for each?

Accepted Answer

Inheritance models an 'is-a' relationship and is appropriate when a subclass is genuinely a specialisation of the parent. Composition models a 'has-a' relationship and is preferred when you want to reuse behaviour without coupling to a class hierarchy — it is more flexible, easier to test, and avoids the fragile base-class problem.

Question 42

What is the difference between CPU-bound and I/O-bound work, and how does the choice affect concurrency strategy in Python?

Accepted Answer

CPU-bound work keeps the processor busy the whole time — matrix multiplication, compression, parsing. I/O-bound work spends most of its time waiting for a slow external resource — network, disk, database. The distinction directly determines which concurrency primitive to reach for: multiprocessing for CPU-bound (bypasses the GIL), threading or asyncio for I/O-bound (GIL released during waits).

Question 43

How does Python's dict work internally, and what makes a good hash key?

Accepted Answer

CPython dicts are open-addressing hash tables. On lookup, Python calls __hash__ on the key to find a slot, then uses __eq__ to confirm the match. A valid dict key must be hashable — immutable by convention — and two objects that compare equal must have the same hash. Hash collisions are resolved by probing, which is why worst-case lookup degrades from O(1) to O(n).

Question 44

What is the contract between `__eq__` and `__hash__` in Python, and what breaks when you define only one?

Accepted Answer

Objects that compare equal must have identical hash values. Python enforces this expectation by setting `__hash__` to `None` whenever you define `__eq__` without `__hash__`, making the object unhashable and ineligible as a dict key or set member. To restore hashability you must define both.

Question 45

What do the else and finally clauses of a try block do, and when does finally NOT run?

Accepted Answer

The else clause runs only when the try block exits without raising an exception — it lets you separate success-path code from the guarded block. The finally clause runs in every case: after normal exit, after an exception (caught or uncaught), and after a return or break inside try or except. The only situations where finally is skipped are a hard interpreter crash (SIGKILL, os._exit, power loss).

Question 46

Why is functools.wraps necessary when writing decorators?

Accepted Answer

Without functools.wraps, the wrapper function replaces the original's __name__, __doc__, __module__, __qualname__, and __annotations__, breaking introspection, logging, and documentation tools. functools.wraps copies all of these attributes from the wrapped function to the wrapper and stores a reference in __wrapped__ for unwrapping.

Question 47

What is the difference between a generator and a list, and when should you prefer a generator?

Accepted Answer

A list materialises all values in memory at once; a generator produces values one at a time on demand, using O(1) memory regardless of the sequence length. Prefer generators for large or infinite sequences, pipelines, and any situation where you do not need random access.

Question 48

What do the global and nonlocal keywords do, and when should you use them?

Accepted Answer

global declares that a name inside a function refers to the module-level variable, allowing reassignment. nonlocal does the same for the nearest enclosing function scope. Both should be used sparingly — they make control flow harder to reason about, and a class or closure that returns a value is usually a cleaner design.

Question 49

What is the difference between `__new__` and `__init__` in Python, and when would you override `__new__`?

Accepted Answer

`__new__` allocates and returns the new object; `__init__` receives that object and populates its attributes. You rarely touch `__new__` — its main legitimate uses are subclassing immutable types like `int` or `str`, and implementing the Singleton pattern.

Question 50

What is the difference between an iterable and an iterator in Python?

Accepted Answer

An iterable implements __iter__ and returns an iterator. An iterator implements both __iter__ (returning itself) and __next__ (producing the next value or raising StopIteration). Every iterator is an iterable, but not every iterable is an iterator.