Python idioms for interviews

# List comprehension with filter
evens = [x for x in nums if x % 2 == 0]

# Dict comprehension — common in interviews for "build index"
idx = {v: i for i, v in enumerate(arr)}

# Set comprehension
seen = {s.lower() for s in words}

# Nested — flatten a 2D grid
flat = [cell for row in grid for cell in row]

# Ternary inside a comprehension
labels = ["even" if x % 2 == 0 else "odd" for x in nums]

# Generator expression — same syntax, parens not brackets, lazy
total = sum(x*x for x in nums if x > 0)

Reach for a comprehension when the body is one expression. If you need an if/else tree or multiple statements, write the loop — comprehensions hurt readability past one condition.

arr[::-1]            # reverse a list or string (O(n) — makes a copy)
arr[i:j]             # half-open, end exclusive
arr[:k], arr[k:]     # first k / from k onward
arr[::2]             # every 2nd element
s[-1]                # last char; s[-k:] for last k

# Multi-assign + swap — O(1), no temp variable
a, b = b, a
prev, curr = curr, prev.next

# Starred unpacking — first / last / middle
first, *rest = [1, 2, 3, 4]      # first=1, rest=[2,3,4]
*init, last = [1, 2, 3, 4]       # init=[1,2,3], last=4
head, *mid, tail = [1, 2, 3, 4]   # head=1, mid=[2,3], tail=4

for i, v in enumerate(arr):       # i = 0, 1, 2, ...
    ...

for a, b in zip(arr1, arr2):       # pairwise; stops at shorter
    ...

for a, b in zip(arr, arr[1:]):     # adjacent pairs trick
    ...

# sorted with key — interview gold
arr.sort(key=lambda x: (x[0], -x[1]))   # asc on x[0], desc on x[1]
sorted(words, key=len)                       # by length
sorted(items, key=lambda p: p.cost)         # by attribute

# min/max with key — one-liner extrema
closest = min(points, key=lambda p: p.x**2 + p.y**2)
longest = max(words, key=len)

# any / all with generators — short-circuit
has_neg = any(x < 0 for x in arr)
all_pos = all(x > 0 for x in arr)

from collections import defaultdict, Counter, deque, OrderedDict

# defaultdict — no more KeyError; "group by" idiom
groups = defaultdict(list)
for word in words:
    groups[tuple(sorted(word))].append(word)   # anagram grouping

# Counter — frequency counts + arithmetic
c1, c2 = Counter("banana"), Counter("nab")
c1 - c2          # multiset subtract: Counter({'a': 2, 'n': 1})
c1 & c2          # intersection (min counts)
c1.most_common(3)  # top-3 by frequency

# deque — O(1) appendleft / popleft, BFS queue
q = deque([root])
while q:
    node = q.popleft()
    for nb in node.neighbors:
        q.append(nb)

from itertools import combinations, permutations, product, pairwise, accumulate, chain

combinations(arr, 3)         # all C(n,3) tuples
permutations(arr, 2)         # all ordered pairs
product([0,1], repeat=3)    # cartesian — bitmask enumeration
pairwise(arr)                # [(a0,a1), (a1,a2), ...] (Py 3.10+)
accumulate(arr)              # running prefix sums
chain(a, b, c)               # concatenate iterables lazily

s.join(parts)            # always faster than += in a loop
", ".join(str(x) for x in nums)

s.split(), s.split(",")
s.strip(), s.lower(), s.upper()
s.isdigit(), s.isalpha(), s.isalnum()
s.startswith(p), s.endswith(p)
s.replace("a", "b")

ord("a") == 97            # char → int; ord('a') - ord('a') = 0 for indexing
chr(97) == "a"            # int → char

# f-strings — debug form with =
n = 42
print(f"{n=}")            # "n=42" — great for debugging
print(f"{n:04d}")         # "0042" — zero-pad
print(f"{ratio:.2f}")      # "0.33"

# Palindrome check — slicing one-liner
def is_palindrome(s): return s == s[::-1]

# Falsy: 0, 0.0, "", [], {}, set(), None, False
if not arr: ...      # empty check — Pythonic
if x is None: ...    # identity check — for None specifically
if x == None: ...    # works but is non-idiomatic; use 'is'

# 'is' vs '==' — identity vs equality
a, b = [1], [1]
a == b      # True  (same value)
a is b      # False (different objects)

# THE classic Python footgun — mutable default arg
def bad(x, acc=[]):       # shared across calls!
    acc.append(x); return acc

def good(x, acc=None):     # the fix
    if acc is None: acc = []
    acc.append(x); return acc

# dict.get / setdefault — avoid the if-else dance
count = freq.get(key, 0) + 1
groups.setdefault(k, []).append(v)

# Integer infinity for DP / comparisons
import math
best = math.inf
for x in arr: best = min(best, x)

# Generator function — yield instead of return
def walk(node):
    if not node: return
    yield node.val
    yield from walk(node.left)
    yield from walk(node.right)

# Memoize recursive DP with one decorator
from functools import cache
@cache
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

# Modern type hints (Py 3.10+) — no more typing imports for basics
def two_sum(nums: list[int], target: int) -> list[int] | None:
    seen: dict[int, int] = {}
    for i, v in enumerate(nums):
        if target - v in seen:
            return [seen[target - v], i]
        seen[v] = i
    return None

Type hints aren't required, but adding them in an interview signals senior fluency — especially the modern list[int] + X | None form over the legacy List[int] + Optional[X].