The Standard Library Modules Worth Knowing Before You pip install

Counting, queues, and dicts with defaults, collections

from collections import Counter, defaultdict, deque

words = "the quick brown fox the lazy dog the fox".split()
counts = Counter(words)
print(counts.most_common(2))   # -> [('the', 3), ('fox', 2)]

groups = defaultdict(list)
for w in words:
    groups[len(w)].append(w)
print(groups[3])   # -> ['the', 'fox', 'the', 'dog', 'the', 'fox']

dq = deque(maxlen=3)          # a bounded ring buffer
for x in range(5):
    dq.append(x)
print(dq)   # -> deque([2, 3, 4], maxlen=3)

Counter is a dict subclass that never raises KeyError for a missing key, it returns 0, and adds most_common(). defaultdict calls its factory (list, int, set, or any zero-argument callable) the first time a key is missing, which removes the if key not in d: boilerplate covered in dicts and sets. deque is a doubly linked queue with O(1) appends and pops from either end, a plain list is O(n) at the front, and maxlen turns it into a fixed-size sliding window for free.

Iterating without writing the loop, itertools and functools

from itertools import chain, groupby, islice
from functools import lru_cache, partial, reduce

print(list(chain([1, 2], [3, 4])))          # -> [1, 2, 3, 4]
print(list(islice(range(1_000_000), 3)))    # -> [0, 1, 2], stops early, no full list built

data = sorted([1, 1, 2, 2, 2, 3])
for key, group in groupby(data):
    print(key, list(group))
# -> 1 [1, 1]
# -> 2 [2, 2, 2]
# -> 3 [3]

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(35))   # -> 9227465, instant on the second call, exponential-time recursion made linear

add_tax = partial(lambda price, rate: price * (1 + rate), rate=0.2)
print(add_tax(100))   # -> 120.0

print(reduce(lambda acc, x: acc * x, [1, 2, 3, 4], 1))   # -> 24

itertools functions return iterators, not lists, islice on a million-element range never materialises the million elements, echoing the laziness from comprehensions and generators. groupby only groups consecutive runs, so sort first if the groups are not already adjacent. lru_cache memoises a pure function’s return value by its arguments, turning naive recursive Fibonacci from exponential into linear time by never recomputing a call it has already seen. partial fixes some arguments of a callable ahead of time; reduce folds a sequence down to one value, useful, but a plain loop or sum/math.prod is usually more readable for the common cases.

Dates, text patterns, randomness, and numbers

from datetime import date, datetime, timedelta

today = date(2026, 11, 14)
print(today + timedelta(days=30))   # -> 2026-12-14
print(datetime.now().isoformat())   # -> e.g. 2026-11-14T09:12:03.481920

import re

m = re.search(r"(\d{4})-(\d{2})-(\d{2})", "seen on 2026-11-14")
print(m.group(0), m.group(1))   # -> 2026-11-14 2026
print(re.sub(r"\s+", " ", "too   many    spaces"))  # -> too many spaces

import random, math, statistics

random.seed(0)
print(random.choice(["a", "b", "c"]))   # -> 'b' (fixed by the seed)
print(math.sqrt(2), math.gcd(48, 18))   # -> 1.4142135623730951 6
print(statistics.mean([1, 2, 3, 4]), statistics.median([1, 2, 3, 4]))  # -> 2.5 2.5

Reach for re for patterns, not for structured formats, an email address or a URL has enough edge cases that a dedicated parser beats a regex; re is right for “does this line start with a timestamp”, not “is this a valid email”. random is not cryptographically secure, use the secrets module for tokens or passwords. statistics is exact and pure Python, appropriate for small datasets; anything large belongs in NumPy.

Talking to the system, os and sys

import os, sys

print(os.environ.get("HOME"))       # -> /Users/you  (or None if unset)
print(sys.argv)                     # -> ['script.py', 'arg1'] when run as `python script.py arg1`
print(sys.version_info[:2])         # -> (3, 13)
sys.exit(1)                         # exits the process with status 1

os covers the environment and process-level operations that pathlib does not (environment variables, process IDs, os.cpu_count()); sys covers the interpreter itself, arguments, the module search path, and exit codes that shells and CI systems check.

Parsing arguments and logging properly

import argparse

parser = argparse.ArgumentParser(description="Greet someone")
parser.add_argument("name")
parser.add_argument("--shout", action="store_true")
args = parser.parse_args(["ada", "--shout"])
greeting = f"hello, {args.name}"
print(greeting.upper() if args.shout else greeting)   # -> HELLO, ADA

Hand-parsing sys.argv with slicing breaks the moment a flag is optional or reordered; argparse generates --help, type-checks (type=int), and reports usage errors with the right exit code, all from a declarative spec.

import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
log = logging.getLogger(__name__)
log.info("starting job")
log.warning("retrying, attempt %d", 2)   # lazy formatting: only built if WARNING is enabled

logging beats print for anything beyond a throwaway script: it has severity levels you can filter by without editing call sites, timestamps and module names for free, and routes to a file or a log aggregator with the same call sites that write to the console today. print debugging has to be found and deleted; a logging.debug call can just be left there, silent, until the level is turned up.

Testing and types

# test_math_utils.py
def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

pytest test_math_utils.py discovers any function named test_* with no boilerplate class or registration, a plain assert is the whole API, and a failure prints the actual values on both sides of the comparison automatically.

from typing import Optional

def greet(name: str, times: int = 1) -> list[str]:
    return [f"hello, {name}"] * times

def find(items: list[int], target: int) -> Optional[int]:
    return items.index(target) if target in items else None

Type hints are not enforced at runtime, greet(5) runs without complaint, but a checker like mypy or pyright catches the mismatch before the code ships, and the annotations double as documentation that cannot silently drift out of date the way a comment can.

Next: idiomatic and performant Python, where these building blocks get put to work at speed.

References

1. Python documentation. collections, Container datatypes.
2. Python documentation. itertools, Functions creating iterators for efficient looping and functools, Higher-order functions.
3. Python documentation. datetime, re, random, statistics.
4. Python documentation. argparse, Parser for command-line options and logging, Logging facility for Python.
5. Python documentation. typing, Support for type hints.
6. pytest documentation. Get Started.
7. van Rossum, G., Lehtosalo, J., & Langa, Ł. PEP 484, Type Hints, 2014.