Standard Library Essentials

In the Python for Beginners series we have mostly reached for third-party packages, but before you install anything, look around: Python ships with a standard library of over 200 modules — batteries included. In this chapter of the 24-chapter series we will tour the pieces you will actually use day to day: collections and itertools for data shaping, pathlib and datetime for files and time, json and re for data interchange and patterns, then argparse and logging for real command-line tools, and finally dataclasses plus functools.lru_cache for tidy classes and free speed.

collections and itertools

The collections module gives you smarter containers: Counter tallies items, defaultdict creates a default the first time you read a missing key, and namedtuple makes a lightweight class with named fields. The itertools module adds looping machinery that is fast because it is written in C. Together they often replace a page of manual loops.

from collections import Counter, defaultdict, namedtuple
import itertools

counts = Counter("abracadabra")
print(counts.most_common(2))

groups = defaultdict(list)
for word in ["bee", "owl", "bat"]:
    groups[word[0]].append(word)
print(dict(groups))

Point = namedtuple("Point", "x y")
print(Point(3, 4), Point(3, 4).x)

pairs = itertools.product("ab", "12")
print(list(pairs))
print(list(itertools.islice(itertools.count(10), 3)))

by_category = {}
for item, category in [("book", "fun"), ("pen", "work"), ("mug", "fun")]:
    by_category.setdefault(category, []).append(item)
print(by_category)

Expected output:

[('a', 5), ('b', 2)]
{'b': ['bee', 'bat'], 'o': ['owl']}
Point(x=3, y=4) 3
[('a', '1'), ('a', '2'), ('b', '1'), ('b', '2')]
[10, 11, 12]
{'fun': ['book', 'mug'], 'work': ['pen']}

pathlib and datetime

Stop concatenating path strings with os.path.join. pathlib.Path makes paths objects, so / means join and methods like exists() and read_text() read naturally. For time, the datetime module gives you datetime for a moment, timedelta for a span, and formatting with strftime.

from pathlib import Path
from datetime import datetime, timedelta

scratch = Path("/tmp") / "demo.txt"
scratch.write_text("hello pathlib")
print(scratch.name, scratch.suffix, scratch.exists(), scratch.read_text())

launch = datetime(2026, 1, 15, 9, 30)
print(launch.strftime("%Y-%m-%d %H:%M"))
print(launch + timedelta(days=7))
print(launch.strftime("%B %d, %Y"))

Expected output:

demo.txt .txt True hello pathlib
2026-01-15 09:30
2026-01-22 09:30:00
January 15, 2026

json and re

Almost every program talks to something else, and json is the lingua franca: json.dumps turns a dict into text, json.loads turns it back. When you need to pull structure out of unstructured text, reach for re. Regex looks frightening, but a few building blocks — \d+ for digits, [A-Z] for a capital, + and * to repeat — cover most jobs. Note the r"" raw strings: they keep backslashes literal.

import json
import re

payload = {"name": "Ada", "langs": ["Python", "Fortran"], "active": True}
text = json.dumps(payload, indent=2)
print(text.splitlines()[0])
back = json.loads(text)
print(back["langs"], back["active"])

msg = "Order A-1024 shipped on 2026-01-15"
order = re.search(r"[A-Z]-\d+", msg).group()
date = re.search(r"\d{4}-\d{2}-\d{2}", msg).group()
print(order, date)
print(re.sub(r"\d+", "#", "qty 12, price 5"))

Expected output:

{
['Python', 'Fortran'] True
A-1024 2026-01-15
qty #, price #

argparse and logging: a real CLI

Two more modules complete the toolbox. argparse declares your command-line flags and writes the help text for you, and logging replaces every print("DEBUG:", x) with levels, timestamps, and handlers you can turn up in production. Together they turn a script into a tool.

import argparse
import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
log = logging.getLogger(__name__)

parser = argparse.ArgumentParser(description="Greet someone.")
parser.add_argument("name", help="who to greet")
parser.add_argument("-n", "--times", type=int, default=1, help="how often")
args = parser.parse_args()

log.info("greeting %s x%s", args.name, args.times)
for _ in range(args.times):
    print(f"Hello, {args.name}!")

Running it with python3 greet.py Ada -n 2:

Expected output:

INFO greeting Ada x2
Hello, Ada!
Hello, Ada!

dataclasses and functools

If you have written a class whose only job is to hold data, dataclasses.dataclass writes the constructor, the representation, and __eq__ for you. And functools.lru_cache memoizes a function, storing results so repeated calls with the same arguments are nearly free — the classic example is recursive Fibonacci, which drops from an exponential crawl to an instant answer.

from dataclasses import dataclass
from functools import lru_cache

@dataclass
class Student:
    name: str
    grades: list

    @property
    def average(self):
        return sum(self.grades) / len(self.grades)

print(Student(name="Ada", grades=[90, 85]))

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

print(fib(30))

Expected output:

Student(name='Ada', grades=[90, 85])
832040

Common mistakes

• Reinventing the container — hand-rolled tallying and grouping loops when Counter and defaultdict already do it, in C. Reach for the library first.
• String paths everywhere — os.path.join concatenation breaks the moment paths get joined twice or read on Windows. Use pathlib.Path objects.
• Swallowing JSON errors — catching every ValueError around json.loads hides the real problem. Let json.JSONDecodeError say what was wrong.
• Regex without raw strings — writing "\d" instead of r"\d" turns backslashes into accidental escapes. Prefix patterns with r.
• print() as a logging strategy — prints cannot be filtered by level or sent to a file. Start with the logging module on day one.

Practice checklist

1. Rebuild one of your older loops using Counter, defaultdict, or itertools.
2. Convert a script that uses os.path to pathlib end to end.
3. Read a config file with json and model it as a dataclass.
4. Give a script a proper CLI with argparse, including --help text.
5. Add logging with two levels (INFO and DEBUG) and switch between them with a flag.

What's next?

You have met the highlights of the standard library — the rest rewards browsing the index at docs.python.org. In the final chapter of this 24-chapter series we pull everything together: Python Best Practices and Where to Go Next turns these lessons into habits and points you at what to learn after this course.