Exercises — Standard library — math, random, os, sys, datetime, time, collections, itertools, functools

collections. Mental model: it is the drawer of "containers with superpowers". Counter counts, defaultdict fills missing keys, deque is a fast two-ended queue, namedtuple gives tuples named fields.

math.comb(8, 3). The word "choose, order ignored, exact integer" points straight at math.comb. It returns the binomial coefficient with no floating-point rounding.

time.perf_counter(). It is the highest-resolution monotonic clock (never jumps backward if the system clock is adjusted). time.time() gives wall-clock seconds-since-1970, which can shift.

Tally the letters of "mississippi": m=1, i=4, s=4, p=2. most_common(2) returns the two highest counts as (item, count) pairs, highest first, ties broken by first-seen order. Since i and s both have count 4, and i appears first in insertion order, the output is:

[('i', 4), ('s', 4)]

random.randint(a, b) is inclusive on both ends, so each draw is one of {1, 2, 3}. Because we called random.seed(0), the sequence is deterministic and reproducible. With CPython's generator, seed 0 yields:

[3, 3, 1, 2]

The value 3 can appear precisely because the top bound is inclusive (unlike range).

import os
print(os.path.join('data', 'raw', 'log.csv'))

On Linux/macOS this prints data/raw/log.csv; on Windows data\raw\log.csv. We use os.path.join (not string +) because the separator differs per operating system, and join picks the right one automatically.

Recall the derivations (see Combinatorics):

• product(A, repeat=3) is all ordered triples from a 2-element set $\Rightarrow 2^3=8$.
• permutations(seq, r) = ordered, no repeats $\Rightarrow \frac{n!}{(n-r)!}=\frac{4!}{2!}=\frac{24}{2}=12$.
• combinations(seq, r) = unordered $\Rightarrow \left(\genfrac{}{}{0ex}{}{4}{2}\right)=\frac{4!}{2!2!}=\frac{24}{4}=6$.

Notice permutations = combinations $\times r!$: $12=6\times 2!$. Order (the $r!$ internal arrangements) is the only difference. See the figure below.

A Python list stores items in one contiguous block. Removing index 0 means every remaining item shifts left by one slot — that is $n-1$ moves, i.e. $O(n)$ per removal (and $O(n^2)$ to drain the whole queue). A deque is a doubly-linked structure of blocks; popleft() just detaches the front end — $O(1)$ per removal, $O(n)$ to drain. Conclusion: for a front-removed queue, deque is asymptotically faster. The figure contrasts the two.

Naive fib(n) = fib(n-1) + fib(n-2) re-computes the same subproblems over and over. The call count grows like the Fibonacci numbers themselves, which grow exponentially: $O({\phi }^n)$ where $\phi \approx 1.618$ — usually quoted as $O(2^n)$. @lru_cache(maxsize=None) stores each computed fib(k) once; a repeat call is a dictionary lookup. So each of the $n+1$ values is computed a single time $\Rightarrow O(n)$ time. This is Recursion and Memoization in one decorator line. LRU = least-recently-used items are evicted first when the cache is bounded.

from collections import defaultdict
words = ['pie', 'pan', 'sun', 'sky', 'apt']
groups = defaultdict(list)
for w in words:
    groups[w[0]].append(w)     # missing key auto-creates an empty list
print(dict(groups))

Output:

{'p': ['pie', 'pan'], 's': ['sun', 'sky'], 'a': ['apt']}

We pass the factory list (uncalled). The first time a new first-letter key is touched, defaultdict calls list() to make [], then we append — no KeyError, no if key not in d boilerplate.

from functools import reduce
result = reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])   # 120

reduce folds left to right: $((((1\times 2)\times 3)\times 4)\times 5)=(((2)\times 3)\times 4)\times 5=120.$ This equals $5!=120$, matching math.factorial(5).

from itertools import chain
from collections import Counter
a = ['red', 'red', 'blue']
b = ['blue', 'green', 'red']
counts = Counter(chain(a, b))       # chain streams both, no merged list built
print(counts.most_common(3))

chain(a, b) yields items lazily from a then b (an iterator), which Counter consumes directly. Tally: red=3, blue=2, green=1. Output:

[('red', 3), ('blue', 2), ('green', 1)]

from functools import wraps
 
def memoize(f):
    cache = {}
    @wraps(f)                       # keep f's name/docstring on the wrapper
    def wrapper(n):
        if n not in cache:
            cache[n] = f(n)
        return cache[n]
    return wrapper
 
@memoize
def fib(n):
    """nth Fibonacci number."""
    return n if n < 2 else fib(n-1) + fib(n-2)
 
print(fib(10))          # 55
print(fib.__name__)     # 'fib'  (thanks to @wraps)

fib(10) = 55. Without @wraps, fib.__name__ would read 'wrapper' and the docstring would be lost — wraps copies the original function's metadata onto the wrapper so tools and help() still see the real fib.

from collections import Counter
 
with open('nums.txt') as fh:
    nums = [int(line) for line in fh]   # strip+int per line
 
total = sum(nums)
most = Counter(nums).most_common(1)[0]  # (value, count) pair
print(total, most)

For a file containing the lines 3, 3, 5, 7, 3, 5: nums = [3,3,5,7,3,5], total = 26, and Counter(...).most_common(1) = [(3, 3)], so most = (3, 3) (the value 3 occurred 3 times). The with block guarantees the file closes even on error.

from itertools import chain
flat = list(chain([1,2],[3,4],[5,6],[7,8],[9,10]))   # [1,2,...,10]

• Repeated + (a + b + c + ...) builds a new list each step, copying all elements accumulated so far. If there are $k$ chunks each of size $m$, the copying cost is $O(k^{2}m)$ — quadratic in the number of chunks.
• chain(...) produces a single lazy stream; wrapping once in list(...) copies each element exactly once $\Rightarrow O(km)$ total (linear).

The flat result is [1,2,3,4,5,6,7,8,9,10] (sum $=55$). chain wins because it avoids re-copying intermediate results.

Choose 3 from 8, exact integer ::: math.comb(8, 3) Front-removal queue, $O(1)$ both ends ::: collections.deque (popleft/appendleft) Turns naive $O(2^n)$ fib into $O(n)$ ::: functools.lru_cache (memoization) permutations(n, r) ÷ combinations(n, r) equals ::: $r!$ Passed to defaultdict — value or factory? ::: the factory (list, not list())