1 · Python fluency for interviews Code

Collections, idioms, built-ins and what each operation costs · the base for every coding question

Why it matters for NPE. The Meta guide grades syntax/language familiarity, structure, bugs and efficiency. In a 45-minute CoderPad round you cannot afford to look up how Counter or sorted(key=) works.

Primer: what "language fluency" means to the grader

The guide says the interviewer scores efficiency, structure, syntax/language familiarity, bugs and correctness. In practice that means: you pick the right container the moment you hear the problem, you write it without pausing to remember an argument order, and you can say the cost of every line. This page is the toolbox. Everything later builds on it.

Watch

The containers and what each operation costs

Dict and set costs are expected O(1) because of hashing. If asked "worst case?", say O(n) with pathological collisions, then move on. Python 3.7+ dicts keep insertion order; sets do not.

Idioms you must type without thinking

# iterate with index, or two sequences in lockstep
for i, host in enumerate(hosts):            # i starts at 0; enumerate(hosts, 1) starts at 1
    ...
for host, status in zip(hosts, statuses):   # stops at the shorter one
    ...

# counting and grouping
from collections import Counter, defaultdict, deque
counts = Counter(words)                     # counts['x'] is 0 for missing keys, no KeyError
counts.most_common(3)                       # [(word, n), ...] highest first
groups = defaultdict(list)
for rec in records:
    groups[rec.region].append(rec)
seen = {}
seen[key] = seen.get(key, 0) + 1            # the manual version of Counter

# sorting
sorted(items, key=lambda x: (-x[1], x[0]))  # count descending, then name ascending
items.sort(key=len)                         # in place, returns None (trap!)
sorted(d.items(), key=lambda kv: kv[1])     # dict by value

# strings
parts = line.strip().split(',')             # strip() first or the last field keeps '\n'
line.split()                                # no argument: any whitespace, drops empties
','.join(fields)                            # fields must all be str
s.lower(), s.isdigit(), s.isalnum(), s.startswith('web-')
f"{host}: {count} failures"

# comprehensions and unpacking
squares = [x * x for x in nums if x % 2 == 0]
lookup = {h.lower(): s for h, s in pairs}
first, *rest = values
a, b = b, a

# truthiness and defaults
if not items:          # empty list/dict/set/str and 0 and None are all falsy
    ...
value = d.get(k) or 'unknown'   # careful: 0 and '' are also "or"-replaced

Mutability: where bugs come from

• Aliasing. b = a does not copy a list. b.append(1) changes a too. Copy with a[:], list(a) or a.copy() (shallow).
• Mutable default argument. def f(x, acc=[]) shares one list across calls. Use acc=None then acc = acc or [].
• Grid aliasing. [[0] * cols] * rows makes one row repeated. Use [[0] * cols for _ in range(rows)].
• In-place methods return None. x = lst.sort(), x = lst.reverse(), x = lst.append(v) all set x to None. Use sorted()/reversed() when you want a value.
• Modifying while iterating. Deleting dict keys inside for k in d raises. Iterate over list(d) or build a new dict.
• Strings are immutable. s += ch in a loop is O(n²) in principle. Collect in a list and ''.join.
• is vs ==. Use is only for None. == compares values.

Reading and writing files (preview of topic 5)

with open(path, encoding='utf-8') as f:    # closes the file even on exceptions
    for line in f:                          # streams one line at a time: O(1) memory per line
        line = line.rstrip('\n')
        if not line:
            continue

Never f.read() or f.readlines() a file you were told might be large. The streaming loop is the answer to "what if the file is 20 GB?"

Big-O in one breath

State the cost in terms of the inputs the interviewer named: n lines, u distinct hosts, k results. "O(n) time to scan the file, O(u) space for the counts, plus O(u log k) to pick the top k with a heap." Common shapes:

Nested loops are not automatically O(n²): a loop over rows and then over that row's cells is O(total cells).

Interview questions

Traps

• Forgetting that split(',') leaves the newline on the last field. strip() the line first.
• range(len(x)) when you also need the value: use enumerate.
• Comparing a str digit to an int: '5' == 5 is False. Convert explicitly with int() and catch ValueError for bad input.
• Using a list as a dict key or set member → TypeError: unhashable. Convert to a tuple.
• max(d) gives the largest key; max(d, key=d.get) gives the key with the largest value.
• Integer division: 7 / 2 is 3.5, 7 // 2 is 3. -7 // 2 is -4 (floors), not -3.
• None is falsy, so if result: drops a legitimate 0. Write if result is not None: when 0 is valid.

Do before marking this topic done

In a blank editor, no autocomplete, write these from memory and run them on tiny inputs:

1. Read lines of host,status from a string split on newlines, count DOWN per host, print hosts sorted by count descending then name.
2. Return the first element that appears exactly once in a list, in O(n).
3. Given a list of (start, end) tuples, return them sorted by start, and say what the sort costs.
4. Implement a FIFO queue with deque and a stack with a list, pushing 3 and popping 3 from each.
5. Return the k largest numbers from a list with heapq.nlargest, then without it using a size-k min-heap.

Then do the three warm-up problems below. They are trivial by design: the goal is zero syntax hesitation.

Practice: linked problems

Logged attempts feed the tracker. Open the problem in a new tab, solve in a blank editor, then log honestly.

• LC 228Summary RangesEasy
• LC 412Fizz BuzzEasy
• LC 1365How Many Numbers Are Smaller Than the Current NumberEasy
• LC 1480Running Sum of 1d ArrayEasy
• LC 1768Merge Strings AlternatelyEasy

all topics · 2 · How a packet gets from A to B →