← Python

Itertools, Functools & Standard Library

← Itertools, Functools & Standard Library

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How does itertools.chain() work and when would you use it?

itertools.chain(*iterables) takes multiple iterables and returns a single iterator that yields elements from each iterable in sequence, exhausting one before moving to the next. It does not create a new list in memory -- it lazily yields elements, making it highly memory-efficient for concatenating large sequences.

There is also itertools.chain.from_iterable(iterable) which takes a single iterable of iterables -- useful when you have a list of lists or a generator of generators.

Use cases:

Concatenating multiple lists/generators without copying
Flattening one level of nested iterables
Processing files from multiple directories sequentially

Pseudo Code

chain(A, B, C):
  for iterable in [A, B, C]:
    for element in iterable:
      yield element

chain.from_iterable([[A, B], [C, D]]):
  for iterable in [[A, B], [C, D]]:
    for element in iterable:
      yield element

Code

from itertools import chain

# Basic chain: concatenate multiple iterables
result = list(chain([1, 2], [3, 4], [5, 6]))
print(result)  # [1, 2, 3, 4, 5, 6]

# chain.from_iterable: flatten one level of nesting
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = list(chain.from_iterable(nested))
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Combining different iterable types
from_list = [1, 2, 3]
from_tuple = (4, 5, 6)
from_set = {7, 8, 9}
result = list(chain(from_list, from_tuple, from_set))
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9] (set order may vary)

# Memory-efficient: works with generators
def gen_a():
    yield from range(3)

def gen_b():
    yield from range(3, 6)

for val in chain(gen_a(), gen_b()):
    print(val, end=' ')  # 0 1 2 3 4 5

[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 8, 9, 7]
0 1 2 3 4 5

Key Points

•chain() lazily yields elements -- no intermediate list is created
•chain.from_iterable() accepts a single iterable of iterables
•Works with any iterable type (lists, tuples, generators, sets)
•Only flattens one level of nesting

Gotchas

•chain() does NOT deep-flatten nested structures; [[1, [2, 3]], [4]] becomes [1, [2, 3], 4]
•If you pass a string to chain(), each character is yielded individually since strings are iterable
•chain.from_iterable() consumes the outer iterable lazily, but each inner iterable is consumed eagerly

itertools.chain(*iterables) lazily concatenates multiple iterables into one. chain.from_iterable() takes a single iterable of iterables. Neither creates an intermediate list.

•Lazily yields elements from multiple iterables in order
•chain.from_iterable() for when you have an iterable of iterables

from itertools import chain

print(list(chain([1, 2], [3, 4])))  # [1, 2, 3, 4]
print(list(chain.from_iterable([[1, 2], [3, 4]])))  # [1, 2, 3, 4]

[1, 2, 3, 4]
[1, 2, 3, 4]

Only flattens one level -- not recursive

Question 2 / 15

Explain itertools.product() and how it differs from nested for loops.

itertools.product(*iterables, repeat=1) computes the Cartesian product of input iterables, which is equivalent to nested for-loops. However, there are important differences:

Cleaner syntax: Replaces deeply nested loops with a single call
Dynamic nesting: The number of iterables can be determined at runtime
repeat parameter: product(A, repeat=3) equals product(A, A, A)

Internally, product() first converts each iterable to a tuple (consuming it), then generates tuples lazily. This means it uses O(n) memory for the input iterables but yields results one at a time.

Pseudo Code

product(A, B):
  # equivalent to:
  for a in A:
    for b in B:
      yield (a, b)

product(A, repeat=2):
  # equivalent to:
  for a1 in A:
    for a2 in A:
      yield (a1, a2)

Code

from itertools import product

# Basic Cartesian product
colors = ['red', 'blue']
sizes = ['S', 'M', 'L']
combinations = list(product(colors, sizes))
print(combinations)
# [('red', 'S'), ('red', 'M'), ('red', 'L'),
#  ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

# Using repeat parameter (same iterable multiple times)
dice_rolls = list(product(range(1, 7), repeat=2))
print(f"Two dice outcomes: {len(dice_rolls)}")  # 36
print(dice_rolls[:5])  # [(1,1), (1,2), (1,3), (1,4), (1,5)]

# Dynamic nesting -- number of loops decided at runtime
binary_digits = [0, 1]
bit_width = 4
all_binary = list(product(binary_digits, repeat=bit_width))
print(f"All {bit_width}-bit combos: {len(all_binary)}")  # 16
print(all_binary[:4])  # [(0,0,0,0), (0,0,0,1), (0,0,1,0), (0,0,1,1)]

# Three-way product
letters = 'AB'
digits = '12'
symbols = '!@'
for combo in product(letters, digits, symbols):
    print(''.join(combo), end=' ')
# A1! A1@ A2! A2@ B1! B1@ B2! B2@

[('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]
Two dice outcomes: 36
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)]
All 4-bit combos: 16
[(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 0), (0, 0, 1, 1)]
A1! A1@ A2! A2@ B1! B1@ B2! B2@

Key Points

•Equivalent to nested for-loops but more readable and dynamic
•The repeat parameter lets you repeat the same iterable N times
•Results are tuples yielded lazily (one at a time)
•Input iterables are converted to tuples internally, so generators are consumed

Gotchas

•Input iterables are fully consumed and stored as tuples, so a huge generator as input will still use memory
•The total number of results is the product of lengths -- can explode combinatorially
•product() with generators only works once since generators are consumed on first pass

itertools.product() computes the Cartesian product (equivalent to nested for-loops). The repeat keyword lets you use the same iterable multiple times.

•Replaces nested for-loops with cleaner syntax
•repeat=N means product(A, A, ..., A) N times

from itertools import product

print(list(product('AB', '12')))  # [('A','1'), ('A','2'), ('B','1'), ('B','2')]
print(list(product([0, 1], repeat=3)))  # all 3-bit binary numbers

[('A', '1'), ('A', '2'), ('B', '1'), ('B', '2')]
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

Input iterables are fully consumed to tuples internally -- not purely lazy on inputs

Question 3 / 15

What is the difference between itertools.permutations() and itertools.combinations()?

Both generate subsequences from an iterable, but they differ in two key ways:

Feature	`permutations(iterable, r)`	`combinations(iterable, r)`
Order matters?	Yes -- (A,B) != (B,A)	No -- only (A,B), not (B,A)
Count	n! / (n-r)!	n! / (r! * (n-r)!)
Repetition	No	No

There is also combinations_with_replacement(iterable, r) which allows elements to repeat.

When to use each:

Permutations: Arrangements where order matters (passwords, seating arrangements)
Combinations: Selections where order doesn't matter (lottery numbers, team selection)
combinations_with_replacement: Selections with repetition (coin combinations, multisets)

Pseudo Code

permutations('ABC', 2) -> AB, AC, BA, BC, CA, CB (6 results)
combinations('ABC', 2) -> AB, AC, BC (3 results)
combinations_with_replacement('ABC', 2) -> AA, AB, AC, BB, BC, CC (6 results)

Code

from itertools import permutations, combinations, combinations_with_replacement

data = ['A', 'B', 'C']

# Permutations: order matters
perms = list(permutations(data, 2))
print(f"Permutations (r=2): {perms}")
# [('A','B'), ('A','C'), ('B','A'), ('B','C'), ('C','A'), ('C','B')]

# Combinations: order doesn't matter
combs = list(combinations(data, 2))
print(f"Combinations (r=2): {combs}")
# [('A','B'), ('A','C'), ('B','C')]

# Combinations with replacement: order doesn't matter, repeats allowed
combs_rep = list(combinations_with_replacement(data, 2))
print(f"Combinations w/ replacement: {combs_rep}")
# [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')]

# Full permutations (all elements)
all_perms = list(permutations(data))
print(f"Full permutations: {len(all_perms)}")  # 6 = 3!

# Practical: find all 3-letter words from given letters
letters = 'cat'
words = [''.join(p) for p in permutations(letters)]
print(words)  # ['cat', 'cta', 'act', 'atc', 'tca', 'tac']

Permutations (r=2): [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
Combinations (r=2): [('A', 'B'), ('A', 'C'), ('B', 'C')]
Combinations w/ replacement: [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
Full permutations: 6
['cat', 'cta', 'act', 'atc', 'tca', 'tac']

Key Points

•Permutations: order matters, (A,B) and (B,A) are different results
•Combinations: order doesn't matter, only unique selections
•combinations_with_replacement allows the same element to appear multiple times
•All three return iterators that yield tuples lazily

Gotchas

•Elements are treated as unique based on position, not value -- permutations([1,1,2], 2) yields (1,1) twice
•permutations() without r defaults to full-length permutations (n!), which grows extremely fast
•These functions do not sort or deduplicate -- duplicates in input cause duplicate output tuples

permutations(iterable, r) yields all r-length ordered arrangements. combinations(iterable, r) yields all r-length unordered selections. Permutations: order matters. Combinations: order doesn't matter.

•Permutations: n!/(n-r)! results, order matters
•Combinations: n!/(r!(n-r)!) results, order does not matter

from itertools import permutations, combinations

print(list(permutations('ABC', 2)))  # 6 results: AB, AC, BA, BC, CA, CB
print(list(combinations('ABC', 2)))  # 3 results: AB, AC, BC

[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
[('A', 'B'), ('A', 'C'), ('B', 'C')]

Duplicate values in input produce duplicate tuples in output

Question 4 / 15

How does itertools.groupby() work and what are its common pitfalls?

itertools.groupby(iterable, key=None) groups consecutive elements that have the same key. This is critically different from SQL's GROUP BY or pandas' groupby, which group all matching elements regardless of position.

How it works:

Iterates through the iterable
Each time the key function returns a different value, it starts a new group
Yields (key_value, group_iterator) pairs

Critical requirement:

The data must be sorted by the key function first if you want to group all matching elements together. Otherwise, you get separate groups for non-consecutive runs.

Pseudo Code

groupby(iterable, key):
  current_key = None
  current_group = []
  for item in iterable:
    k = key(item)
    if k != current_key:
      if current_group:
        yield current_key, iter(current_group)
      current_key = k
      current_group = [item]
    else:
      current_group.append(item)
  yield current_key, iter(current_group)

Code

from itertools import groupby
from operator import itemgetter

# Basic groupby on sorted data
data = [('Alice', 'A'), ('Bob', 'A'), ('Charlie', 'B'), ('Diana', 'B'), ('Eve', 'A')]

# WRONG: data not sorted by grade -- Eve's 'A' is separate from Alice/Bob's 'A'
for key, group in groupby(data, key=lambda x: x[1]):
    print(f"{key}: {list(group)}")
# A: [('Alice', 'A'), ('Bob', 'A')]
# B: [('Charlie', 'B'), ('Diana', 'B')]
# A: [('Eve', 'A')]  <-- separate group!

# CORRECT: sort first, then groupby
data_sorted = sorted(data, key=lambda x: x[1])
for key, group in groupby(data_sorted, key=lambda x: x[1]):
    print(f"{key}: {list(group)}")
# A: [('Alice', 'A'), ('Bob', 'A'), ('Eve', 'A')]
# B: [('Charlie', 'B'), ('Diana', 'B')]

# Grouping consecutive identical elements
text = 'aaabbccddddee'
for char, group in groupby(text):
    print(f"{char}: {sum(1 for _ in group)}", end='  ')
# a: 3  b: 2  c: 2  d: 4  e: 2

# Run-length encoding
def rle_encode(s):
    return [(char, sum(1 for _ in group)) for char, group in groupby(s)]

print(rle_encode('aaabbccddddee'))
# [('a', 3), ('b', 2), ('c', 2), ('d', 4), ('e', 2)]

A: [('Alice', 'A'), ('Bob', 'A')]
B: [('Charlie', 'B'), ('Diana', 'B')]
A: [('Eve', 'A')]
A: [('Alice', 'A'), ('Bob', 'A'), ('Eve', 'A')]
B: [('Charlie', 'B'), ('Diana', 'B')]
a: 3  b: 2  c: 2  d: 4  e: 2  [('a', 3), ('b', 2), ('c', 2), ('d', 4), ('e', 2)]

Key Points

•Groups CONSECUTIVE elements with the same key -- not all elements globally
•Data must be sorted by the key first for global grouping
•Yields (key, group_iterator) pairs
•Great for run-length encoding and consecutive-element analysis

Gotchas

•The group iterator is invalidated when you advance to the next group -- consume it immediately with list()
•Forgetting to sort first is the #1 bug -- you get fragmented groups
•The group iterator shares the underlying iterable, so storing it without consuming leads to empty groups

itertools.groupby() groups consecutive elements with the same key. You must sort the data by the key first to get global grouping. Yields (key, group_iterator) pairs.

•Groups consecutive elements only -- sort first for global groups
•Consume each group iterator immediately or it gets lost

from itertools import groupby

data = sorted([3, 1, 2, 1, 3], key=lambda x: x)
for k, g in groupby(data):
    print(k, list(g))  # 1 [1,1]  2 [2]  3 [3,3]

1 [1, 1]
2 [2]
3 [3, 3]

Advancing to next group invalidates the previous group iterator

Question 5 / 15

What are itertools.islice(), count(), cycle(), and repeat() used for?

These are utility iterators for controlling iteration flow:

`itertools.count(start=0, step=1)`

Infinite counter. Yields start, start+step, start+2*step, ... forever. Works with floats.

`itertools.cycle(iterable)`

Infinitely repeats an iterable. Consumes the iterable into memory on first pass, then cycles.

`itertools.repeat(object, times=None)`

Yields the same object repeatedly. If times is given, stops after that many. Often used with map() or starmap() for constant arguments.

`itertools.islice(iterable, stop)` / `islice(iterable, start, stop, step)`

Lazy slicing for iterators. Unlike list[start:stop:step], works on any iterable without converting to a list. Cannot use negative indices.

Pseudo Code

count(10, 2)  -> 10, 12, 14, 16, ...  (infinite)
cycle('AB')  -> A, B, A, B, A, B, ... (infinite)
repeat(5, 3) -> 5, 5, 5              (finite)
islice(count(), 5, 10, 2) -> 5, 7, 9 (lazy slice)

Code

from itertools import count, cycle, repeat, islice

# count: infinite counter
for i in islice(count(10, 0.5), 5):
    print(i, end=' ')  # 10 10.5 11.0 11.5 12.0
print()

# count with zip to add indices
data = ['a', 'b', 'c']
indexed = list(zip(count(1), data))
print(indexed)  # [(1, 'a'), (2, 'b'), (3, 'c')]

# cycle: round-robin assignment
teams = cycle(['Red', 'Blue', 'Green'])
players = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
assignment = {p: next(teams) for p in players}
print(assignment)
# {'Alice': 'Red', 'Bob': 'Blue', 'Charlie': 'Green',
#  'Diana': 'Red', 'Eve': 'Blue', 'Frank': 'Green'}

# repeat: constant argument for map/starmap
from itertools import starmap
import operator
powers = list(starmap(operator.pow, zip(range(1, 5), repeat(2))))
print(powers)  # [1, 4, 9, 16] -- each number squared

# islice: lazy slicing on any iterable
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Get fibonacci numbers at positions 10-15
fib_slice = list(islice(fibonacci(), 10, 16))
print(fib_slice)  # [55, 89, 144, 233, 377, 610]

# islice for first N elements of a large file
# first_lines = list(islice(open('huge.log'), 10))

10 10.5 11.0 11.5 12.0
[(1, 'a'), (2, 'b'), (3, 'c')]
{'Alice': 'Red', 'Bob': 'Blue', 'Charlie': 'Green', 'Diana': 'Red', 'Eve': 'Blue', 'Frank': 'Green'}
[1, 4, 9, 16]
[55, 89, 144, 233, 377, 610]

Key Points

•count() is an infinite counter that works with any numeric type
•cycle() memorizes the iterable and repeats it forever
•repeat() is useful as a constant-value iterator for map/starmap
•islice() provides lazy slicing without loading the full iterable into memory

Gotchas

•cycle() stores the entire iterable in memory -- do not cycle over a huge generator
•islice() does not support negative indices (no way to know length of an iterator)
•count() with float steps can accumulate floating-point errors; use (start + step*i) pattern for precision
•All infinite iterators will run forever if not bounded by islice, zip, or takewhile

count(start, step): infinite counter. cycle(iterable): infinite repeater. repeat(obj, n): yield same object n times. islice(iter, start, stop, step): lazy slice for iterators.

•count/cycle are infinite -- always bound them
•islice is lazy slicing for any iterable

from itertools import count, cycle, repeat, islice

print(list(islice(count(0, 2), 5)))  # [0, 2, 4, 6, 8]
print(list(islice(cycle('AB'), 6)))  # ['A','B','A','B','A','B']
print(list(repeat(42, 3)))           # [42, 42, 42]

[0, 2, 4, 6, 8]
['A', 'B', 'A', 'B', 'A', 'B']
[42, 42, 42]

islice does not support negative indices

Question 6 / 15

How do itertools.starmap() and itertools.tee() work?

`itertools.starmap(function, iterable)`

Like map(), but unpacks each element of the iterable as arguments to the function using *. While map(f, [(a,b), (c,d)]) passes each tuple as a single argument, starmap(f, [(a,b), (c,d)]) calls f(a,b) and f(c,d).

`itertools.tee(iterable, n=2)`

Creates n independent iterators from a single iterable. Once tee is called, the original iterable should not be used anymore. Internally, tee uses shared storage -- elements consumed by one iterator but not yet by others are kept in memory.

Pseudo Code

starmap(func, [(a,b), (c,d)]):
  yield func(a, b)
  yield func(c, d)

tee(iterable, 3):
  return iter1, iter2, iter3  # all independent copies

Code

from itertools import starmap, tee
import operator

# starmap: unpack arguments from tuples
pairs = [(2, 5), (3, 2), (10, 3)]
results = list(starmap(pow, pairs))  # pow(2,5), pow(3,2), pow(10,3)
print(results)  # [32, 9, 1000]

# Compare with map
print(list(map(pow, [2, 3, 10], [5, 2, 3])))  # same result, different input format

# starmap with lambda
points = [(1, 2), (3, 4), (5, 6)]
distances = list(starmap(lambda x, y: (x**2 + y**2)**0.5, points))
print(distances)  # [2.236, 5.0, 7.81]

# tee: create independent copies of an iterator
data = iter(range(5))
iter1, iter2, iter3 = tee(data, 3)

print(list(iter1))  # [0, 1, 2, 3, 4]
print(list(iter2))  # [0, 1, 2, 3, 4] -- independent copy
print(list(iter3))  # [0, 1, 2, 3, 4] -- independent copy

# Practical: pairwise iteration
def pairwise(iterable):
    a, b = tee(iterable)
    next(b, None)  # advance second iterator by one
    return zip(a, b)

print(list(pairwise([1, 2, 3, 4, 5])))
# [(1, 2), (2, 3), (3, 4), (4, 5)]

[32, 9, 1000]
[32, 9, 1000]
[2.23606797749979, 5.0, 7.810249675906654]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[(1, 2), (2, 3), (3, 4), (4, 5)]

Key Points

•starmap unpacks each element as *args to the function
•tee creates n independent iterators from one source
•pairwise iteration is a classic tee use case
•After tee(), do not use the original iterator

Gotchas

•tee stores elements in memory until all copies have consumed them -- if one iterator is far ahead, memory grows
•Using the original iterator after tee() will consume elements that tee copies miss
•tee is not thread-safe
•For large iterables where one copy is consumed much faster, consider list() instead of tee()

starmap(f, [(a,b),(c,d)]) calls f(a,b) and f(c,d) -- like map but unpacks arguments. tee(iterable, n) creates n independent iterator copies from one source.

•starmap unpacks tuples as function arguments
•tee creates independent iterator copies

from itertools import starmap, tee

print(list(starmap(pow, [(2,3), (3,2)])))  # [8, 9]

a, b = tee(range(3))
print(list(a), list(b))  # [0,1,2] [0,1,2]

[8, 9]
[0, 1, 2] [0, 1, 2]

tee stores unconsumed elements in memory -- can be costly if iterators diverge

Question 7 / 15

How does itertools.accumulate() work and how does it differ from functools.reduce()?

itertools.accumulate(iterable, func=operator.add, *, initial=None) yields running (cumulative) results of a binary function. It is similar to functools.reduce() but with a key difference:

accumulate: Yields all intermediate results (lazy iterator)
reduce: Returns only the final result

accumulate is like a scan/prefix-sum operation. It defaults to addition but accepts any two-argument function.

Pseudo Code

accumulate([1,2,3,4], add):  -> 1, 3, 6, 10  (all intermediates)
reduce([1,2,3,4], add):      -> 10             (final only)

accumulate([3,1,4,1], max):   -> 3, 3, 4, 4    (running maximum)

Code

from itertools import accumulate
from functools import reduce
import operator

# Running sum (default)
nums = [1, 2, 3, 4, 5]
print(list(accumulate(nums)))  # [1, 3, 6, 10, 15]

# Compare with reduce -- only gets final value
print(reduce(operator.add, nums))  # 15

# Running product
print(list(accumulate(nums, operator.mul)))  # [1, 2, 6, 24, 120]

# Running maximum
data = [3, 1, 4, 1, 5, 9, 2, 6]
print(list(accumulate(data, max)))  # [3, 3, 4, 4, 5, 9, 9, 9]

# With initial value
print(list(accumulate([1, 2, 3], initial=100)))  # [100, 101, 103, 106]

# Practical: running balance
transactions = [1000, -200, -150, 500, -300]
balances = list(accumulate(transactions))
print(f"Balances: {balances}")  # [1000, 800, 650, 1150, 850]
print(f"Min balance: {min(balances)}")  # 650

# Custom function: running average (using enumerate trick)
def running_avg(prev_avg, new_val):
    # This doesn't work perfectly -- need index info
    pass

# Better approach for running average
from itertools import accumulate
sums = accumulate([10, 20, 30, 40, 50])
averages = [s / i for i, s in enumerate(sums, 1)]
print(averages)  # [10.0, 15.0, 20.0, 25.0, 30.0]

[1, 3, 6, 10, 15]
15
[1, 2, 6, 24, 120]
[3, 3, 4, 4, 5, 9, 9, 9]
[100, 101, 103, 106]
Balances: [1000, 800, 650, 1150, 850]
Min balance: 650
[10.0, 15.0, 20.0, 25.0, 30.0]

Key Points

•accumulate yields ALL intermediate results; reduce yields only the final result
•Default function is addition (running sum)
•Accepts any two-argument function (max, min, mul, custom)
•The initial parameter adds a starting value before the first element

Gotchas

•accumulate is lazy (returns iterator), reduce is eager (returns single value)
•The initial parameter was added in Python 3.8 -- not available in earlier versions
•accumulate always includes the first element as-is (or initial if provided) -- no function call for first element

accumulate() yields all intermediate cumulative results; reduce() returns only the final one. accumulate defaults to addition. Both accept a custom binary function.

•accumulate = all intermediates (lazy); reduce = final only (eager)
•Default function is addition

from itertools import accumulate
from functools import reduce

print(list(accumulate([1,2,3,4])))  # [1, 3, 6, 10]
print(reduce(lambda a,b: a+b, [1,2,3,4]))  # 10
print(list(accumulate([3,1,4,1,5], max)))  # [3, 3, 4, 4, 5]

[1, 3, 6, 10]
10
[3, 3, 4, 4, 5]

First element is yielded as-is, no function applied to it

Question 8 / 15

Explain functools.reduce() with practical examples. When should you avoid it?

functools.reduce(function, iterable[, initializer]) applies a two-argument function cumulatively to items of an iterable, reducing it to a single value. It processes left-to-right: reduce(f, [a,b,c,d]) computes f(f(f(a,b), c), d).

Guido van Rossum himself has argued against overuse of reduce, saying it's often less readable than a simple for-loop. Python 3 moved it from builtins to functools for this reason.

When to use reduce:

Composing functions
Computing values where no built-in exists (e.g., GCD of a list)
Functional programming patterns

When to avoid:

When sum(), math.prod(), min(), max(), any(), all() do the job
When a for-loop is more readable

Pseudo Code

reduce(f, [a, b, c, d], init):
  result = init
  result = f(result, a)
  result = f(result, b)
  result = f(result, c)
  result = f(result, d)
  return result

Code

from functools import reduce
import operator
from math import gcd

# Basic: sum (but sum() is better)
total = reduce(operator.add, [1, 2, 3, 4, 5])
print(total)  # 15

# Product (Python 3.8+ has math.prod)
product = reduce(operator.mul, [1, 2, 3, 4, 5])
print(product)  # 120

# GCD of multiple numbers
numbers = [24, 36, 48, 60]
result = reduce(gcd, numbers)
print(f"GCD: {result}")  # 12

# Flatten nested list (one level)
nested = [[1, 2], [3, 4], [5, 6]]
flat = reduce(operator.add, nested)  # list concatenation
print(flat)  # [1, 2, 3, 4, 5, 6]

# With initializer
result = reduce(operator.add, [], 0)  # safe on empty iterable
print(result)  # 0

# Function composition
def compose(*funcs):
    return reduce(lambda f, g: lambda x: f(g(x)), funcs)

double = lambda x: x * 2
add_one = lambda x: x + 1
square = lambda x: x ** 2

transform = compose(square, add_one, double)  # square(add_one(double(x)))
print(transform(3))  # square(add_one(6)) = square(7) = 49

# Building a dict from pairs
pairs = [('a', 1), ('b', 2), ('c', 3)]
# Don't do this -- dict() is better
result = reduce(lambda d, kv: {**d, kv[0]: kv[1]}, pairs, {})
print(result)  # {'a': 1, 'b': 2, 'c': 3}

15
120
GCD: 12
[1, 2, 3, 4, 5, 6]
0
49
{'a': 1, 'b': 2, 'c': 3}

Key Points

•Applies a function cumulatively left-to-right, producing a single result
•The initializer prevents errors on empty iterables and acts as the starting value
•Moved to functools in Python 3 (was a builtin in Python 2)
•Best for GCD, function composition, and custom reductions with no built-in equivalent

Gotchas

•Without an initializer, reduce on an empty iterable raises TypeError
•Often less readable than a simple for-loop or built-in (sum, math.prod, min, max)
•Using reduce for list flattening creates a new list each step -- O(n^2) for list concatenation
•reduce processes left-to-right only; for right-fold, reverse the iterable first

functools.reduce(f, iterable, init) applies f cumulatively to reduce an iterable to one value. Use it for GCD or function composition, but prefer built-ins like sum(), min(), max() when they fit.

•Cumulative left-to-right reduction to a single value
•Always provide initializer for potentially empty iterables

from functools import reduce
from math import gcd

print(reduce(gcd, [24, 36, 48]))  # 12
print(reduce(lambda a, b: a * b, [1, 2, 3, 4]))  # 24

12
24

Empty iterable without initializer raises TypeError

Question 9 / 15

How do functools.partial() and functools.partialmethod() work?

functools.partial(func, *args, **kwargs) returns a new callable that "freezes" some arguments of the original function. This is a form of partial application (not to be confused with currying, which produces a chain of single-argument functions).

functools.partialmethod() is the same concept but designed for use inside class definitions where the first argument is self.

Use cases:

Configuring callbacks with pre-set arguments
Creating specialized versions of general functions
Adapting functions to expected signatures (e.g., for map/filter)

Pseudo Code

partial(func, a, b=5):
  return new_func where:
    new_func(c, d) == func(a, c, d, b=5)

# Frozen args come first, then remaining positional args

Code

from functools import partial, partialmethod

# Basic partial
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(5))    # 125

# Partial with positional args
int_from_binary = partial(int, base=2)
print(int_from_binary('1010'))  # 10
print(int_from_binary('1111'))  # 15

# Using partial with map
from operator import mul
double = partial(mul, 2)
result = list(map(double, [1, 2, 3, 4]))
print(result)  # [2, 4, 6, 8]

# Inspecting partial objects
print(square.func)      # <function power>
print(square.args)      # ()
print(square.keywords)  # {'exponent': 2}

# partialmethod inside a class
class Cell:
    def __init__(self):
        self._alive = False

    def set_state(self, state):
        self._alive = state

    set_alive = partialmethod(set_state, True)
    set_dead = partialmethod(set_state, False)

cell = Cell()
cell.set_alive()
print(cell._alive)  # True
cell.set_dead()
print(cell._alive)  # False

# Partial for callback configuration
import logging
log_warning = partial(logging.log, logging.WARNING)
log_warning("This is a warning message")

25
125
10
15
[2, 4, 6, 8]
<function power at <address>>
()
{'exponent': 2}
True
False

Key Points

•partial freezes some arguments, returning a new callable with fewer parameters
•Frozen positional args are prepended; keyword args are merged
•partial objects have .func, .args, and .keywords attributes for introspection
•partialmethod is for use in class bodies where self is handled automatically

Gotchas

•Frozen positional args always come first -- you cannot skip positional arguments
•partial does not validate arguments at creation time; errors appear only when called
•partial objects are not picklable in all Python versions (improved in 3.x)
•Keyword args from partial can be overridden at call time, which may cause confusion

functools.partial(func, *args, **kwargs) freezes some arguments, returning a new callable. partialmethod does the same for methods in a class.

•Freezes arguments to create specialized functions
•Inspect with .func, .args, .keywords

from functools import partial

int_bin = partial(int, base=2)
print(int_bin('1010'))  # 10

from operator import mul
double = partial(mul, 2)
print(list(map(double, [1,2,3])))  # [2, 4, 6]

10
[2, 4, 6]

Positional args are always prepended -- cannot skip positions

Question 10 / 15

How does functools.lru_cache work and what are its limitations?

functools.lru_cache(maxsize=128, typed=False) is a decorator that memoizes function results using a Least Recently Used (LRU) eviction policy. When the cache is full and a new entry needs to be added, the least recently accessed entry is discarded.

Parameters:

maxsize: Maximum number of cached results. None means unlimited cache (never evicts). Should be a power of 2 for best performance.
typed: If True, arguments of different types are cached separately (e.g., f(3) and f(3.0) are separate entries).

Python 3.9+ also provides @functools.cache which is equivalent to lru_cache(maxsize=None) -- simpler syntax for unlimited cache.

How it works:

Function arguments are hashed to create a cache key
A doubly-linked list tracks access order for LRU eviction
Thread-safe (uses a lock internally)

Pseudo Code

lru_cache stores results in dict:
  key = hash(args, kwargs)
  value = function_result

On call:
  if key in cache:
    move to front (most recent)
    return cached value
  else:
    result = call function
    store in cache
    if len(cache) > maxsize:
      evict least recently used
    return result

Code

from functools import lru_cache, cache

# Classic example: Fibonacci
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025 (instant, without cache would be very slow)

# Cache info and management
print(fibonacci.cache_info())
# CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

fibonacci.cache_clear()  # clear the cache

# typed=True: different types cached separately
@lru_cache(maxsize=32, typed=True)
def process(value):
    print(f"Computing for {value!r} (type={type(value).__name__})")
    return value * 2

process(3)    # prints "Computing for 3 (type=int)"
process(3.0)  # prints "Computing for 3.0 (type=float)" -- separate cache entry
process(3)    # cache hit, no print

# Python 3.9+ shorthand
@cache  # equivalent to lru_cache(maxsize=None)
def factorial(n):
    return n * factorial(n - 1) if n else 1

print(factorial(10))  # 3628800

# Practical: expensive computation caching
@lru_cache(maxsize=256)
def fetch_user_permissions(user_id: int, role: str) -> set:
    # Simulating expensive DB query
    print(f"DB query for user {user_id}, role {role}")
    return {f"perm_{i}" for i in range(5)}

fetch_user_permissions(1, 'admin')  # DB query
fetch_user_permissions(1, 'admin')  # cache hit
fetch_user_permissions(1, 'user')   # DB query (different args)

12586269025
CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)
Computing for 3 (type=int)
Computing for 3.0 (type=float)
3628800
DB query for user 1, role admin
DB query for user 1, role user

Key Points

•LRU eviction policy removes least recently accessed entries when cache is full
•Use .cache_info() to monitor hits/misses and .cache_clear() to reset
•maxsize=None means unlimited cache; Python 3.9 @cache is shorthand for this
•Thread-safe by default

Gotchas

•All arguments must be hashable (no lists or dicts as args) -- use tuple instead
•Caches based on exact argument match -- f(a=1, b=2) and f(b=2, a=1) are separate entries
•Memory can grow unbounded with maxsize=None -- be careful with large result objects
•Does not work with methods that take self (self is part of the key, so each instance gets separate entries); use per-instance caching instead

@lru_cache(maxsize=128) memoizes function results with LRU eviction. Arguments must be hashable. Use .cache_info() to inspect and .cache_clear() to reset. Python 3.9+ has @cache for unlimited caching.

•Memoizes with LRU eviction; maxsize=None for unlimited
•All arguments must be hashable

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

print(fib(50))  # 12586269025
print(fib.cache_info())  # CacheInfo(hits=48, misses=51, ...)

12586269025
CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

Lists/dicts as arguments cause TypeError -- convert to tuples/frozensets

Question 11 / 15

What is functools.singledispatch and how do you use it for function overloading?

functools.singledispatch transforms a function into a single-dispatch generic function. It dispatches on the type of the first argument, allowing you to register specialized implementations for different types -- similar to function overloading in statically typed languages.

For methods, Python 3.8+ provides functools.singledispatchmethod.

How it works:

Decorate the base function with @singledispatch
Register type-specific implementations with @func.register(type)
At call time, dispatch selects the most specific registered implementation based on the first argument's type

Pseudo Code

@singledispatch
def process(arg):      # default/fallback
    ...

@process.register(int)
def _(arg):            # called when arg is int
    ...

@process.register(str)
def _(arg):            # called when arg is str
    ...

Code

from functools import singledispatch, singledispatchmethod

@singledispatch
def format_value(value):
    """Default handler for unknown types."""
    return f"Unknown: {value!r}"

@format_value.register(int)
def _(value):
    return f"Integer: {value:,}"

@format_value.register(float)
def _(value):
    return f"Float: {value:.2f}"

@format_value.register(str)
def _(value):
    return f"String: '{value}'"

@format_value.register(list)
def _(value):
    return f"List[{len(value)} items]: {value}"

# Type annotations style (Python 3.7+)
@format_value.register
def _(value: dict):
    return f"Dict[{len(value)} keys]: {list(value.keys())}"

print(format_value(42))           # Integer: 42
print(format_value(3.14159))      # Float: 3.14
print(format_value("hello"))      # String: 'hello'
print(format_value([1, 2, 3]))    # List[3 items]: [1, 2, 3]
print(format_value({"a": 1}))     # Dict[1 keys]: ['a']
print(format_value(None))         # Unknown: None

# singledispatchmethod for classes
class Serializer:
    @singledispatchmethod
    def serialize(self, value):
        raise TypeError(f"Cannot serialize {type(value)}")

    @serialize.register(int)
    @serialize.register(float)
    def _(self, value):
        return str(value)

    @serialize.register(str)
    def _(self, value):
        return f'"{value}"'

s = Serializer()
print(s.serialize(42))       # '42'
print(s.serialize("hello"))  # '"hello"'

Integer: 42
Float: 3.14
String: 'hello'
List[3 items]: [1, 2, 3]
Dict[1 keys]: ['a']
Unknown: None
42
"hello"

Key Points

•Dispatches on the type of the first argument only
•The base function serves as the default/fallback handler
•Register implementations with @func.register(type) or type annotations
•singledispatchmethod (3.8+) works with class methods

Gotchas

•Only dispatches on the FIRST argument's type -- cannot do multi-dispatch natively
•Does not work with typing generics (List[int] vs List[str] -- both dispatch as list)
•ABCs can be registered but dispatch order for overlapping types follows MRO
•singledispatchmethod must be the outermost decorator when combined with @classmethod or @staticmethod

@singledispatch provides function overloading based on the first argument's type. Register type-specific handlers with @func.register(type). Unrecognized types fall through to the base function.

•Dispatch on first argument type only
•Base function is the fallback for unregistered types

from functools import singledispatch

@singledispatch
def show(val):
    print(f"Unknown: {val}")

@show.register(int)
def _(val):
    print(f"Int: {val}")

@show.register(str)
def _(val):
    print(f"Str: {val}")

show(42)       # Int: 42
show("hello")  # Str: hello
show([1, 2])   # Unknown: [1, 2]

Int: 42
Str: hello
Unknown: [1, 2]

Only single dispatch (first argument) -- no multi-dispatch

Question 12 / 15

Explain functools.total_ordering and functools.wraps. When are they essential?

`functools.total_ordering`

A class decorator that automatically generates missing comparison methods. You only need to define __eq__ and one of __lt__, __le__, __gt__, or __ge__, and it fills in the rest.

`functools.wraps`

A decorator for decorator functions that copies metadata (__name__, __doc__, __module__, __qualname__, __dict__, __wrapped__) from the original function to the wrapper. Without it, the decorated function loses its identity.

When essential:

total_ordering: When you have a custom class that needs all 6 comparison operators but writing all of them is redundant.
wraps: In every decorator you write. Without it, debugging becomes harder (function names show as "wrapper" in tracebacks), and tools like help(), inspect, and Sphinx break.

Pseudo Code

total_ordering:
  You define __eq__ and __lt__
  It auto-generates __le__, __gt__, __ge__

wraps:
  @wraps(original_func)  # copies metadata
  def wrapper(*args, **kwargs):
      return original_func(*args, **kwargs)

Code

from functools import total_ordering, wraps
import time

# total_ordering example
@total_ordering
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def __eq__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.grade == other.grade

    def __lt__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self.grade < other.grade

    def __repr__(self):
        return f"Student({self.name!r}, {self.grade})"

a = Student('Alice', 90)
b = Student('Bob', 85)
c = Student('Charlie', 90)

# These all work even though we only defined __eq__ and __lt__
print(a > b)   # True  (auto-generated)
print(a >= c)  # True  (auto-generated)
print(b <= a)  # True  (auto-generated)
print(sorted([a, b, c]))  # [Student('Bob', 85), Student('Alice', 90), ...]

# wraps example
def timer(func):
    @wraps(func)  # preserves func's metadata
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    """A function that simulates slow work."""
    time.sleep(0.01)
    return 42

# With @wraps: metadata is preserved
print(slow_function.__name__)  # 'slow_function' (not 'wrapper')
print(slow_function.__doc__)   # 'A function that simulates slow work.'
print(slow_function.__wrapped__)  # original function reference

# Without @wraps, you'd get:
# slow_function.__name__ -> 'wrapper'
# slow_function.__doc__  -> None

True
True
True
[Student('Bob', 85), Student('Alice', 90), Student('Charlie', 90)]
slow_function
A function that simulates slow work.
<function slow_function at <address>>

Key Points

•total_ordering needs __eq__ and one comparison method to generate the rest
•wraps copies __name__, __doc__, __module__, __qualname__, __wrapped__ from the original
•wraps also copies __dict__ and updates __wrapped__ for access to the original function
•Both are essential for writing clean, maintainable Python

Gotchas

•total_ordering auto-generated methods are slower than hand-written ones (they compose from the defined methods)
•total_ordering requires returning NotImplemented for incompatible types, not raising TypeError
•Without @wraps, inspect.signature() returns the wrapper's signature, breaking documentation tools
•@wraps should be used in EVERY decorator -- it is a common interview red flag to omit it

@total_ordering auto-generates missing comparison methods from __eq__ + one of __lt__/__gt__/__le__/__ge__. @wraps(func) preserves the original function's metadata in decorators.

•total_ordering: define __eq__ + one comparator, get all six
•wraps: always use in decorators to preserve function identity

from functools import total_ordering, wraps

@total_ordering
class Box:
    def __init__(self, size): self.size = size
    def __eq__(self, other): return self.size == other.size
    def __lt__(self, other): return self.size < other.size

def my_decorator(func):
    @wraps(func)
    def wrapper(*a, **kw): return func(*a, **kw)
    return wrapper

total_ordering is slower than hand-written comparisons

Question 13 / 15

How does collections.Counter work and what are its most useful operations?

collections.Counter is a dict subclass for counting hashable objects. It maps elements to their counts. It supports several powerful operations:

Arithmetic: +, - (drops zero/negative), & (intersection/min), | (union/max)
most_common(n): Returns the n most frequent elements
elements(): Returns an iterator over elements repeating each as many times as its count
subtract(): Like update() but subtracts counts
total(): Sum of all counts (Python 3.10+)

Counter is essentially a multiset (bag) data structure.

Pseudo Code

Counter(['a', 'b', 'a', 'c', 'a', 'b'])
-> Counter({'a': 3, 'b': 2, 'c': 1})

Counter('abracadabra').most_common(3)
-> [('a', 5), ('b', 2), ('r', 2)]

Code

from collections import Counter

# Creation methods
c1 = Counter('abracadabra')
c2 = Counter({'red': 4, 'blue': 2})
c3 = Counter(cats=4, dogs=8)
print(c1)  # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

# most_common
words = 'the cat sat on the mat the cat'.split()
word_counts = Counter(words)
print(word_counts.most_common(2))  # [('the', 3), ('cat', 2)]

# Missing keys return 0 (not KeyError)
print(word_counts['elephant'])  # 0

# Arithmetic operations
inventory = Counter(apples=5, oranges=3)
sold = Counter(apples=2, oranges=1, bananas=1)
remaining = inventory - sold  # drops zero/negative
print(remaining)  # Counter({'apples': 3, 'oranges': 2})

# Union and intersection
a = Counter(x=3, y=2, z=1)
b = Counter(x=1, y=4, w=2)
print(a | b)  # Counter({'y': 4, 'x': 3, 'w': 2, 'z': 1})  -- max of each
print(a & b)  # Counter({'y': 2, 'x': 1})  -- min of each (positive only)

# elements() iterator
c = Counter(a=3, b=1)
print(sorted(c.elements()))  # ['a', 'a', 'a', 'b']

# Practical: anagram check
def is_anagram(s1, s2):
    return Counter(s1.lower().replace(' ', '')) == Counter(s2.lower().replace(' ', ''))

print(is_anagram('listen', 'silent'))  # True

# Practical: find duplicates
data = [1, 2, 3, 2, 4, 3, 5, 2]
duplicates = [item for item, count in Counter(data).items() if count > 1]
print(duplicates)  # [2, 3]

Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
[('the', 3), ('cat', 2)]
0
Counter({'apples': 3, 'oranges': 2})
Counter({'y': 4, 'x': 3, 'w': 2, 'z': 1})
Counter({'y': 2, 'x': 1})
['a', 'a', 'a', 'b']
True
[2, 3]

Key Points

•Counter is a dict subclass that maps elements to counts
•Missing keys return 0 instead of raising KeyError
•Supports arithmetic (+, -, &, |) for combining counters
•most_common(n) returns the n highest-count elements

Gotchas

•Subtraction drops zero and negative counts -- use subtract() to keep them
•Counter({'a': 0}) is different from Counter() -- the key exists with count 0
•elements() ignores zero and negative counts
•Counter is unordered in Python < 3.7 (follows dict ordering in 3.7+)

Counter is a dict subclass for counting hashable items. Missing keys return 0. Supports arithmetic (+, -, &, |) and most_common(n) for top-N elements.

•Dict subclass for counting; missing keys return 0
•most_common(n) and arithmetic (+, -, &, |) are key features

from collections import Counter

c = Counter('abracadabra')
print(c.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]
print(c['z'])  # 0 (no KeyError)
print(Counter('abc') + Counter('bcd'))  # Counter({'b': 2, 'c': 2, 'a': 1, 'd': 1})

[('a', 5), ('b', 2), ('r', 2)]
0
Counter({'b': 2, 'c': 2, 'a': 1, 'd': 1})

Subtraction drops zero/negative counts unless you use subtract()

Question 14 / 15

Explain collections.defaultdict, namedtuple, and deque with use cases.

`defaultdict(default_factory)`

A dict subclass that calls default_factory to supply missing keys. Instead of raising KeyError, it creates the value automatically. Common factories: list, int, set, lambda: default_value.

`namedtuple(typename, field_names)`

Creates an immutable tuple subclass with named fields. Provides readability of a class with the efficiency of a tuple. Python 3.6+ also has typing.NamedTuple for type-annotated version.

`deque(iterable=(), maxlen=None)`

Double-ended queue with O(1) append/pop from both ends. Lists are O(n) for insert(0, x) and pop(0) but deque handles both ends efficiently.

Pseudo Code

defaultdict(list): d['missing'] -> []
defaultdict(int):  d['missing'] -> 0

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2); p.x -> 1

deque: appendleft, popleft -> O(1)
       maxlen auto-discards oldest

Code

from collections import defaultdict, namedtuple, deque

# defaultdict: auto-create missing values
# Group items by category
products = [('fruit', 'apple'), ('vegetable', 'carrot'),
            ('fruit', 'banana'), ('vegetable', 'broccoli')]

grouped = defaultdict(list)
for category, item in products:
    grouped[category].append(item)  # no need to check if key exists
print(dict(grouped))  # {'fruit': ['apple', 'banana'], 'vegetable': ['carrot', 'broccoli']}

# defaultdict(int) for counting
word_count = defaultdict(int)
for word in 'the cat sat on the mat'.split():
    word_count[word] += 1
print(dict(word_count))  # {'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}

# Nested defaultdict
tree = lambda: defaultdict(tree)
filesystem = tree()
filesystem['home']['user']['documents']['file.txt'] = 'content'
print(filesystem['home']['user']['documents']['file.txt'])  # 'content'

# namedtuple: readable tuples
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y)       # 3 4
print(p[0], p[1])     # 3 4 (still a tuple)
print(p._asdict())    # {'x': 3, 'y': 4}
p2 = p._replace(x=10) # immutable, returns new instance
print(p2)             # Point(x=10, y=4)

# namedtuple with defaults (Python 3.6.1+)
Config = namedtuple('Config', ['host', 'port', 'debug'], defaults=['localhost', 8080, False])
print(Config())  # Config(host='localhost', port=8080, debug=False)

# deque: efficient double-ended queue
dq = deque([1, 2, 3])
dq.appendleft(0)  # O(1)
dq.append(4)      # O(1)
print(dq)          # deque([0, 1, 2, 3, 4])
dq.popleft()       # O(1) -- list.pop(0) is O(n)
print(dq)          # deque([1, 2, 3, 4])

# deque as sliding window
window = deque(maxlen=3)
for i in range(6):
    window.append(i)
    print(list(window), end=' ')
# [0] [0,1] [0,1,2] [1,2,3] [2,3,4] [3,4,5]

# deque.rotate
dq = deque([1, 2, 3, 4, 5])
dq.rotate(2)   # rotate right
print(dq)      # deque([4, 5, 1, 2, 3])
dq.rotate(-2)  # rotate left
print(dq)      # deque([1, 2, 3, 4, 5])

{'fruit': ['apple', 'banana'], 'vegetable': ['carrot', 'broccoli']}
{'the': 2, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1}
content
3 4
3 4
{'x': 3, 'y': 4}
Point(x=10, y=4)
Config(host='localhost', port=8080, debug=False)
deque([0, 1, 2, 3, 4])
deque([1, 2, 3, 4])
[0] [0, 1] [0, 1, 2] [1, 2, 3] [2, 3, 4] [3, 4, 5] deque([4, 5, 1, 2, 3])
deque([1, 2, 3, 4, 5])

Key Points

•defaultdict eliminates KeyError by auto-creating missing values with a factory function
•namedtuple creates immutable, lightweight objects with named fields
•deque provides O(1) append/pop from both ends; maxlen creates a fixed-size sliding window
•deque.rotate() rotates elements in-place

Gotchas

•defaultdict's factory is called for ANY missing key access, including d[key] in boolean checks -- this creates entries silently
•namedtuple instances are immutable -- use _replace() to create modified copies
•deque is slower than list for random access (O(n) for d[i] in the middle)
•namedtuple field names cannot start with underscore or be Python keywords

defaultdict(factory): dict that auto-creates missing values. namedtuple: immutable tuple with named fields. deque: double-ended queue with O(1) append/pop on both ends.

•defaultdict: auto-creates values for missing keys
•namedtuple: immutable tuple with named fields
•deque: O(1) on both ends, optional maxlen

from collections import defaultdict, namedtuple, deque

d = defaultdict(list)
d['key'].append(1)  # no KeyError

Point = namedtuple('Point', 'x y')
p = Point(1, 2)

dq = deque([1, 2, 3], maxlen=5)
dq.appendleft(0)  # O(1)

defaultdict creates entries on ANY access, even reads of missing keys

Question 15 / 15

What is the operator module and how does it improve functional programming in Python?

The operator module provides function equivalents of Python's built-in operators. These are faster than lambdas (implemented in C) and more readable in functional programming contexts.

Key functions:

Arithmetic: add, sub, mul, truediv, floordiv, mod, pow
Comparison: eq, ne, lt, le, gt, ge
Logical: and_, or_, not_
Item access: itemgetter(key) -- returns a callable that gets item[key]
Attribute access: attrgetter(attr) -- returns a callable that gets obj.attr
Method calling: methodcaller(name, *args) -- calls obj.name(*args)

Why use them:

Faster than equivalent lambdas (C implementation)
More readable in map/reduce/sorted calls
Picklable (lambdas are not)

Pseudo Code

operator.add(a, b)        == a + b
itemgetter('key')(d)      == d['key']
attrgetter('name')(obj)   == obj.name
methodcaller('upper')(s)  == s.upper()

# Multi-key versions:
itemgetter(0, 2)(lst)     == (lst[0], lst[2])
attrgetter('a', 'b')(obj) == (obj.a, obj.b)

Code

from operator import add, mul, itemgetter, attrgetter, methodcaller
from functools import reduce

# Arithmetic operators with reduce/map
numbers = [1, 2, 3, 4, 5]
print(reduce(add, numbers))  # 15 (cleaner than lambda a,b: a+b)
print(reduce(mul, numbers))  # 120

# itemgetter for sorting dicts
students = [
    {'name': 'Alice', 'grade': 90, 'age': 20},
    {'name': 'Bob', 'grade': 85, 'age': 22},
    {'name': 'Charlie', 'grade': 90, 'age': 19},
]

# Sort by grade (descending), then name (ascending)
by_grade_name = sorted(students, key=lambda s: (-s['grade'], s['name']))
print([s['name'] for s in by_grade_name])  # ['Alice', 'Charlie', 'Bob']

# itemgetter for single key
by_name = sorted(students, key=itemgetter('name'))
print([s['name'] for s in by_name])  # ['Alice', 'Bob', 'Charlie']

# Multi-key itemgetter
get_name_grade = itemgetter('name', 'grade')
print(get_name_grade(students[0]))  # ('Alice', 90)

# attrgetter with named tuples
from collections import namedtuple
Point = namedtuple('Point', 'x y')
points = [Point(3, 4), Point(1, 2), Point(5, 0)]
sorted_by_x = sorted(points, key=attrgetter('x'))
print(sorted_by_x)  # [Point(x=1, y=2), Point(x=3, y=4), Point(x=5, y=0)]

# Nested attrgetter
class Department:
    def __init__(self, name, manager):
        self.name = name
        self.manager = manager

class Manager:
    def __init__(self, name):
        self.name = name

depts = [Department('Engineering', Manager('Alice')),
         Department('Sales', Manager('Bob'))]
sorted_depts = sorted(depts, key=attrgetter('manager.name'))
print([d.manager.name for d in sorted_depts])  # ['Alice', 'Bob']

# methodcaller
strings = ['hello world', 'foo bar', 'python rocks']
result = list(map(methodcaller('upper'), strings))
print(result)  # ['HELLO WORLD', 'FOO BAR', 'PYTHON ROCKS']

# methodcaller with arguments
result = list(map(methodcaller('split', ' ', 1), strings))
print(result)  # [['hello', 'world'], ['foo', 'bar'], ['python', 'rocks']]

15
120
['Alice', 'Charlie', 'Bob']
['Alice', 'Bob', 'Charlie']
('Alice', 90)
[Point(x=1, y=2), Point(x=3, y=4), Point(x=5, y=0)]
['Alice', 'Bob']
['HELLO WORLD', 'FOO BAR', 'PYTHON ROCKS']
[['hello', 'world'], ['foo', 'bar'], ['python', 'rocks']]

Key Points

•operator functions are C-implemented and faster than equivalent lambdas
•itemgetter, attrgetter, and methodcaller return reusable callables
•Multi-key versions return tuples: itemgetter(0, 2) returns (item[0], item[2])
•attrgetter supports dotted names for nested attribute access

Gotchas

•operator.and_ and operator.or_ are bitwise, not logical -- use operator.and_ for & not 'and'
•itemgetter does not handle missing keys gracefully -- raises KeyError/IndexError
•These functions are not composable without functools.partial or lambda wrappers
•methodcaller creates a new callable each time -- store it in a variable if reusing

The operator module provides C-implemented function equivalents of operators. itemgetter('key'), attrgetter('attr'), and methodcaller('method') return callables -- faster and more readable than lambdas in sorted(), map(), etc.

•Faster than lambdas (C implementation), picklable
•itemgetter/attrgetter/methodcaller are the most useful

from operator import itemgetter, attrgetter, add

data = [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}]
print(sorted(data, key=itemgetter('name')))  # sorted by name
print(itemgetter('name', 'age')(data[0]))    # ('Bob', 25)

[{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]
('Bob', 25)

operator.and_/or_ are bitwise, not boolean logical operators

Built by onllm.dev

Home GitHub Support awesomePrep

How does itertools.chain() work and when would you use it?

Use cases:

Explain itertools.product() and how it differs from nested for loops.

What is the difference between itertools.permutations() and itertools.combinations()?

When to use each:

How does itertools.groupby() work and what are its common pitfalls?

How it works:

Critical requirement:

What are itertools.islice(), count(), cycle(), and repeat() used for?

itertools.count(start=0, step=1)

itertools.cycle(iterable)

itertools.repeat(object, times=None)

itertools.islice(iterable, stop) / islice(iterable, start, stop, step)

How do itertools.starmap() and itertools.tee() work?

itertools.starmap(function, iterable)

itertools.tee(iterable, n=2)

How does itertools.accumulate() work and how does it differ from functools.reduce()?

Explain functools.reduce() with practical examples. When should you avoid it?

When to use reduce:

When to avoid:

How do functools.partial() and functools.partialmethod() work?

Use cases:

How does functools.lru_cache work and what are its limitations?

Parameters:

How it works:

What is functools.singledispatch and how do you use it for function overloading?

How it works:

Explain functools.total_ordering and functools.wraps. When are they essential?

functools.total_ordering

functools.wraps

When essential:

How does collections.Counter work and what are its most useful operations?

Explain collections.defaultdict, namedtuple, and deque with use cases.

defaultdict(default_factory)

namedtuple(typename, field_names)

deque(iterable=(), maxlen=None)

What is the operator module and how does it improve functional programming in Python?

Key functions:

Why use them:

Itertools, Functools & Standard Library

`itertools.count(start=0, step=1)`

`itertools.cycle(iterable)`

`itertools.repeat(object, times=None)`

`itertools.islice(iterable, stop)` / `islice(iterable, start, stop, step)`

`itertools.starmap(function, iterable)`

`itertools.tee(iterable, n=2)`

`functools.total_ordering`

`functools.wraps`

`defaultdict(default_factory)`

`namedtuple(typename, field_names)`

`deque(iterable=(), maxlen=None)`