Q: from module import * risks

The real danger of `import *` is namespace pollution. If two modules both export a name like `open` or `filter`, the second import silently overwrites the first - and there is no warning. You end up calling a completely different function than you intended, and the bug is nearly invisible because the name still works. Explicit imports (`from module import specific_name`) make the source of every name unambiguous and prevent this class of error entirely.

Q: itertools.accumulate running total

itertools.accumulate yields running totals: 1, 1+2=3, 3+3=6, 6+4=10, 10+5=15. The result includes one value per input element, starting with the first element unchanged. The last value is the sum of the entire input. This is useful for prefix sum arrays, which let you answer range-sum queries in O(1) after O(n) setup - a pattern that appears often in interview problems involving subarray sums.

Question 1

__name__ == '__main__' guard

Accepted Answer

When Python runs a file directly, it sets `__name__` to `'__main__'`. When the same file is imported as a module, `__name__` becomes the module's name instead. The guard lets you write code - like `main()` calls or test scaffolding - that only fires during direct execution. Without it, that code would run every time someone imported the file, which can cause unexpected side effects in tests or other scripts.

Question 2

Counter missing key behavior

Accepted Answer

Counter is designed for counting, so accessing a missing key returns 0 instead of raising a KeyError. The letter 'h' appears once in 'hello', so `c['h']` is 1. 'z' is not in the string, but Counter silently returns 0 rather than throwing an error - unlike a regular dict, which would raise KeyError. This behavior makes frequency counting code much cleaner.

Question 3

deque vs list for front removal

Accepted Answer

A Python list is backed by a contiguous array. Removing from position 0 requires shifting every remaining element one slot to the left, which is O(n). A deque uses a doubly-linked block structure so it can remove from either end in O(1). For BFS queues or any pattern that repeatedly pulls from the front, this difference matters a lot at scale.

Question 4

Counter.most_common output

Accepted Answer

Counter.most_common(n) returns a list of the n most frequent (element, count) tuples, ordered from highest to lowest count. Passing 2 limits the result to the top 2. Each item in the list is a tuple, not a dict entry. This method is the clean, one-line replacement for sorting a frequency dict manually.

Question 5

Implementing a max-heap with heapq

Accepted Answer

Python's heapq always maintains the smallest element at the top. The standard workaround is to push `-x` instead of `x`. When you pop, the smallest negative value corresponds to the largest original value - so negate it again on the way out. This idiom is universally understood by Python developers and comes up constantly in interview problems involving the k-th largest element or a running maximum.

Question 6

itertools.combinations count

Accepted Answer

Combinations choose r items from n without regard to order and without repetition, so the count is C(4, 2) = 6. Each combination is returned as a tuple, not a list. The function preserves the input order, so the first combination is always (1, 2). If you needed (2, 1) as a separate result, you'd want permutations instead.

Question 7

defaultdict auto-create on access

Accepted Answer

After the three append calls, `d` has keys 'a' and 'b', so its length is 2. But accessing `d['c']` doesn't raise a KeyError - defaultdict creates the key with the default factory (an empty list) and returns it. After that access, 'c' is now in `d`, making the length 3. The tricky part is that just reading `d['c']` mutates the dict by adding the key.

Question 8

heapq with tuple ordering

Accepted Answer

heapq compares tuples element by element. The first pop returns (1, 'urgent') because 1 is the smallest first element. The two remaining tuples both have priority 2, so Python breaks the tie by comparing the second element as strings. 'also medium' starts with 'a' (ASCII 97) while 'medium' starts with 'm' (ASCII 109), so 'also medium' < 'medium' - making (2, 'also medium') the smaller tuple. The second pop therefore returns (2, 'also medium'). The practical lesson: when you push tuples into a heap and two priorities are equal, Python will try to compare the next field. If that field is not comparable (like a custom object), you get a TypeError - so always include a unique tiebreaker as the second element in production code.

Question 9

from module import * risks

Accepted Answer

The real danger of `import *` is namespace pollution. If two modules both export a name like `open` or `filter`, the second import silently overwrites the first - and there is no warning. You end up calling a completely different function than you intended, and the bug is nearly invisible because the name still works. Explicit imports (`from module import specific_name`) make the source of every name unambiguous and prevent this class of error entirely.

Question 10

itertools.accumulate running total

Accepted Answer

itertools.accumulate yields running totals: 1, 1+2=3, 3+3=6, 6+4=10, 10+5=15. The result includes one value per input element, starting with the first element unchanged. The last value is the sum of the entire input. This is useful for prefix sum arrays, which let you answer range-sum queries in O(1) after O(n) setup - a pattern that appears often in interview problems involving subarray sums.

Question 11

What the GIL is

Accepted Answer

The GIL is a design choice in CPython (the reference implementation) that simplifies memory management by ensuring only one thread runs at a time. This means CPU-bound tasks do not truly parallelize with threads - if you spawn 4 threads to crunch numbers, they still take turns rather than running simultaneously. The workarounds are: use multiprocessing (separate processes, each with its own GIL), use I/O-bound threads (threads release the GIL while waiting on I/O), or use a GIL-free runtime like Jython or PyPy-STM.

Modules & Stdlib