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

The map of drawers (the 20% that gives 80%)

Module	What it's FOR (one word)	Killer tools
`math`	Pure-number math	`sqrt, floor, ceil, gcd, factorial, pi, comb, log`
`random`	Pseudo-randomness	`random, randint, choice, shuffle, sample, seed`
`os`	Talk to the OS / files	`getcwd, listdir, path.join, environ, makedirs`
`sys`	Talk to the interpreter	`argv, exit, path, maxsize`
`datetime`	Calendar dates & times	`datetime.now, timedelta, strftime, strptime`
`time`	Clock / sleep / timing	`time(), sleep(), perf_counter()`
`collections`	Better containers	`Counter, defaultdict, deque, namedtuple`
`itertools`	Lazy looping algebra	`count, cycle, product, permutations, combinations, chain, groupby`
`functools`	Tools that act on functions	`reduce, lru_cache, partial, wraps`

math — exact numeric helpers

Worked example Distance between two points

import math
d = math.hypot(3, 4)      # 5.0

Why hypot? It computes $\sqrt{3^2+4^2}$ but avoids overflow by scaling internally — math.sqrt(3**2+4**2) works here but breaks for huge numbers.

random — controllable chance

Worked example

import random
random.seed(42)
random.randint(1, 6)       # dice roll, both ends inclusive
random.choice(['a','b','c'])
random.sample(range(10), 3)  # 3 unique items (no repeats)
random.shuffle(my_list)      # in-place

Why randint(1,6) includes 6? Because it's designed for human "1 to 6" thinking — unlike range, the upper end is inclusive.

os & sys — the environment vs the interpreter

Worked example Build a safe path

import os
os.path.join('data', 'raw', 'file.csv')   # 'data/raw/file.csv' on Linux, '\\' on Windows

Why not just 'data/' + 'file.csv'? Because the separator differs per OS. os.path.join is portable — that's the whole point.

Worked example Command-line arguments

import sys
# run: python script.py hello 7
sys.argv          # ['script.py', 'hello', '7']
sys.exit(0)       # 0 = success, nonzero = error

Why is argv[0] the script name? Convention inherited from C — the program "knows its own name."

datetime & time — two different clocks

Worked example Date arithmetic

from datetime import datetime, timedelta
now = datetime.now()
tomorrow = now + timedelta(days=1)
now.strftime('%Y-%m-%d')               # format → string
datetime.strptime('2024-01-31', '%Y-%m-%d')  # parse string → object

Why timedelta? Adding 1 to a date is ambiguous (1 second? day?). timedelta makes the unit explicit. Memory: format = to string, parse = from string (strf vs strp).

Worked example Timing code

import time
t0 = time.perf_counter()
work()
print(time.perf_counter() - t0, "seconds")

Why perf_counter not time.time()? perf_counter is the highest-resolution monotonic clock — it never jumps backward if the system clock is adjusted.

collections — containers with superpowers

Worked example Counting words

from collections import Counter, defaultdict, deque
Counter("banana")              # Counter({'a':3,'n':2,'b':1})
Counter("banana").most_common(2)  # [('a',3),('n',2)]
 
d = defaultdict(list)
d['fruits'].append('apple')    # key auto-created as []
 
q = deque([1,2,3])
q.appendleft(0); q.pop()       # fast on both sides

Why deque over list for a queue? Removing from the front of a list is $O(n)$ (shift everything). deque.popleft() is $O(1)$ .

itertools — lazy looping algebra

Worked example

from itertools import product, permutations, combinations, chain, groupby, count
list(product([0,1], repeat=2))      # [(0,0),(0,1),(1,0),(1,1)]
list(permutations('ABC', 2))        # 6 ordered pairs
list(combinations('ABC', 2))        # 3 unordered: AB AC BC
list(chain([1,2],[3,4]))            # [1,2,3,4]  (flatten)

functools — tools that operate ON functions

Worked example Memoization with

lru_cache

from functools import lru_cache, reduce
 
@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)
 
reduce(lambda a,b: a*b, [1,2,3,4])   # 24  (factorial-style product)

Why lru_cache? Naive fib recomputes the same subproblems exponentially ( $O(2^n)$ ). The cache stores each result once → $O(n)$ . LRU = least-recently-used items get evicted when the cache is full.

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

Common mistakes (Steel-man + fix)

Active-recall flashcards

Which module for Counter, defaultdict, deque?

collections

math.comb(n,k) returns what, and as what type?

\binom{n}{k}=\frac{n!}{k!(n-k)!}

, as an exact integer

Is random.randint(1,6) inclusive of 6?

Yes — both endpoints are inclusive

Difference between strftime and strptime?

strf = format object→string; strp = parse string→object

Why use os.path.join instead of string +?

It uses the correct OS separator → portable code

Why time.perf_counter() over time.time() for timing?

Highest-resolution monotonic clock; never jumps backward

Size of permutations(n, r)?

n!/(n-r)!

Size of combinations(n, r)?

\binom{n}{r}=n!/(r!(n-r)!)

What does functools.reduce(f,[a,b,c]) compute?

f(f(a,b),c)

— left-fold accumulation

What does lru_cache do for recursive fib?

Memoizes results → turns

O(2^n)

into

O(n)

Why pass list not list() to defaultdict?

defaultdict calls the factory itself when a key is missing

What is sys.argv[0]?

The script's own name

Why is deque.popleft() better than list.pop(0)?

O(1)

O(n)

(no shifting)

Recall Feynman: explain to a 12-year-old

Imagine a huge toolbox that comes free with your bike. One drawer (math) has number gadgets, one (random) is a dice cup, one (os) talks to your computer about files, one (collections) has magic boxes that count things by themselves, and one (itertools) is a machine that makes every possible combination of your stickers without you doing it by hand. You don't need to make these tools — they're already in the box. You just need to know which drawer to open.

Connections

Python Iterators and Generators — why itertools is lazy
Big-O Notation — why deque/lru_cache change complexity
Recursion and Memoization — lru_cache deep dive
Combinatorics — math.comb, permutations, combinations formulas
File Handling in Python — pairs with os and os.path
Decorators — functools.wraps, lru_cache, partial

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, Python ki sabse badi taakat hai uska standard library — yeh ek aisa toolbox hai jo Python install karte hi free mein milta hai, kuch alag se download nahi karna padta. Soch lo har module ek drawer hai jisme ready-made, tested aur C-fast functions bhare pade hain. Aapko har function ratne ki zaroorat nahi — bas yeh yaad rakho ki kaun sa kaam kaunse drawer mein hai. Yahi 80/20 rule hai: thoda map yaad karo, bahut saara kaam ho jayega.

Quick tour: math single numbers ke liye (sqrt, comb, gcd), random dice/chance ke liye (aur seed se same sequence dobara aata hai — testing mein bahut kaam ka), os files aur folders ke liye, sys Python interpreter se baat karne ke liye (jaise sys.argv command-line arguments). datetime calendar dates ke liye aur time timing/sleep ke liye — yeh do alag cheezein hain, confuse mat hona.

collections mein superpowers wale containers hain: Counter cheezein automatic gin leta hai, defaultdict missing key par error nahi deta, aur deque dono taraf se $O(1)$ mein add/remove karta hai. itertools lazy hota hai — matlab on-demand items banata hai, isliye combinations aur permutations jaise combinatorics problems isse mast solve hote hain. Aur functools mein lru_cache hai jo recursive fibonacci ko $O(2^n)$ se $O(n)$ bana deta hai — magic memoization!

Yeh isliye matter karta hai kyunki interviews aur real projects mein log apna code chhota aur reliable rakhte hain — wheel dobara nahi banate. Jab aap sahi drawer khol lete ho, aapka code chhota, fast aur bug-free ho jaata hai.

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

The map of drawers (the 20% that gives 80%)

math — exact numeric helpers

random — controllable chance

os & sys — the environment vs the interpreter

datetime & time — two different clocks

collections — containers with superpowers

itertools — lazy looping algebra

functools — tools that operate ON functions

Common mistakes (Steel-man + fix)

Active-recall flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Python Intermediate

Connections