Standard library deep dive

Make a day21 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days. Nothing needs installing today: every module on this page comes with Python.

On Day 8 you wrote eight lines to count words and find the most common one. On Day 4 you worked out the rule for leap years. Both jobs are so common that Python already has them, written, tested, and fast, in its standard library: the collection of modules that comes with every Python installation (Day 13 toured math, random, datetime, os, and sys). Today you meet five more modules that replace whole loops you have been writing by hand: collections for counting and grouping, itertools for combining iterables, datetime (properly this time) for calendars and clocks, re for finding patterns in text, and argparse for reading command-line options. The habit to take away is as important as any one module: before you write a utility yourself, look for it in the standard library first.

Counting things is everywhere: votes, words, page visits, dice rolls. Day 8’s pattern works, but you write it every time, with an empty dictionary, a loop, and counts.get(item, 0) + 1. Then you write Day 5’s maximum loop to find the winner, and a second, longer loop if you want the top three. The collections module (“specialized collection types”) has a type that does all of that.

A Counter is a dictionary made for counting. Hand it any iterable (a list, a string, a generator), and it counts each different item: the items become the keys, and their counts become the values. Because it is a dictionary, everything from Day 8 still works on it: [], in, items(), len().

>>> from collections import Counter
>>> votes = Counter(["pizza", "tacos", "pizza", "sushi", "pizza", "tacos"])
>>> votes
Counter({'pizza': 3, 'tacos': 2, 'sushi': 1})
>>> votes["pizza"]
3
>>> votes["curry"]
0
>>> len(votes)
3
>>> votes.most_common(2)
[('pizza', 3), ('tacos', 2)]
>>> votes.total()
6
>>> votes["sushi"] += 1
>>> votes.update(["curry", "pizza"])
>>> votes
Counter({'pizza': 4, 'tacos': 2, 'sushi': 2, 'curry': 1})

• Counter([...]) does the whole Day 8 loop in one call. It shows the counts from the most common down.
• votes["curry"] gives 0 for an item that was never counted, instead of a KeyError. Reading a missing key does not add it: len(votes) is still 3.
• most_common(n) returns the n most common items as a list of (item, count) tuples, biggest count first. Without n, it returns them all.
• total() adds up all the counts: six votes in all.
• Because a missing count reads as 0, votes["sushi"] += 1 works even for a new item, with no get needed. update(iterable) counts more items into the same Counter.

When two items have the same count, most_common keeps them in the order they were first counted. So a tie always comes out the same way, run after run.

from collections import Counter

sales = "apple pear apple plum pear apple kiwi plum apple pear".split()
counts = Counter(sales)

print(f"{counts.total()} sales of {len(counts)} kinds of fruit")
for fruit, count in counts.most_common(3):
    print(fruit, count, "*" * count)
print("Kiwis:", counts["kiwi"], "Mangoes:", counts["mango"])

10 sales of 4 kinds of fruit
apple 4 ****
pear 3 ***
plum 2 **
Kiwis: 1 Mangoes: 0

>>> from collections import Counter
>>> Counter("to be or not to be")
Counter({' ': 5, 'o': 4, 't': 3, 'b': 2, 'e': 2, 'r': 1, 'n': 1})
>>> Counter("to be or not to be".split())
Counter({'to': 2, 'be': 2, 'or': 1, 'not': 1})

from collections import Counter

letters = Counter("mississippi")
print(letters.most_common(2))
print(letters["p"], letters["z"], len(letters))
letters.update("pop")
print(letters.most_common(1), letters.total())

[('i', 4), ('s', 4)]
2 0 4
[('i', 4)] 14

Day 8’s grouping pattern has the same shape as counting: before you can append to a key’s list, you check whether the key exists and, if not, add it with an empty list. Those two lines run only the first time each key appears, yet you write them every time. A defaultdict (also from collections) is a dictionary that fills in a missing key for you, the moment you use it.

You create it with a default factory: a function that defaultdict calls, with no arguments, to make the starting value for each new key. Day 10 showed that a function is a value you can pass around without calling it. The built-in types work as factories, because calling one with no arguments makes an “empty” value:

>>> from collections import defaultdict
>>> int()
0
>>> list()
[]
>>> minutes = defaultdict(int)
>>> minutes["reading"] += 30
>>> minutes["math"] += 45
>>> minutes["reading"] += 20
>>> minutes
defaultdict(<class 'int'>, {'reading': 50, 'math': 45})
>>> dict(minutes)
{'reading': 50, 'math': 45}

• int() gives 0 and list() gives []. So defaultdict(int) starts each new key at 0, and defaultdict(list) starts each new key with an empty list. Pass the function itself, int or list, with no parentheses.
• minutes["reading"] += 30 reads a key that does not exist yet. Instead of raising KeyError, the defaultdict calls int(), stores the 0, and then adds 30.
• Printing it shows the factory, <class 'int'>, and then the ordinary dictionary. dict(minutes) turns it into a plain dictionary when you want plainer output.

from collections import defaultdict

names = ["Ben", "Ana", "Bea", "Cal", "Abe", "Bo"]

by_letter: defaultdict[str, list[str]] = defaultdict(list)
for name in names:
    by_letter[name[0]].append(name)

for letter, group in by_letter.items():
    print(letter, group)

B ['Ben', 'Bea', 'Bo']
A ['Ana', 'Abe']
C ['Cal']

Counter and defaultdict(int) can both count. Use Counter when you want counts and the extras (most_common, total); use defaultdict(int) or defaultdict(float) when you are adding up amounts by category, as in Day 8’s spending totals.

from collections import defaultdict

by_letter: defaultdict[str, list[str]] = defaultdict(list)
for name in ["Ben", "Ana", "Bea"]:
    by_letter[name[0]].append(name)

for letter in "ABZ":
    if by_letter[letter]:
        print(letter, by_letter[letter])
    else:
        print(letter, "nobody")
print(len(by_letter), "letters:", list(by_letter))

A ['Ana']
B ['Ben', 'Bea']
Z nobody
3 letters: ['B', 'A', 'Z']

from collections import defaultdict

purchases = [("food", 12.5), ("games", 20.0), ("food", 8.25), ("books", 9.99)]
spending: defaultdict[str, float] = defaultdict(float)
for category, amount in purchases:
    spending[category] += amount

print(spending["food"], spending["toys"])
print(len(spending), sorted(spending))

20.75 0.0
4 ['books', 'food', 'games', 'toys']

Day 7 stored a student as a tuple, ("Ana", 10, 92). That is compact and cannot change by accident, but code like student[2] makes the reader stop and count: is position 2 the grade or the score? A dictionary has names, but nothing stops a typo creating a new key, and Day 17’s @dataclass is a whole class. For a small, fixed record, there is something in between.

namedtuple (from collections) makes a new tuple type whose positions also have names. You call it with the type’s name and a list of field names, and it gives back a class (Day 16), which you name in CapWords:

>>> from collections import namedtuple
>>> Student = namedtuple("Student", ["name", "grade", "score"])
>>> ana = Student("Ana", 10, 92)
>>> ana
Student(name='Ana', grade=10, score=92)
>>> ana.score
92
>>> ana[0]
'Ana'
>>> name, grade, score = ana
>>> grade
10
>>> ana == ("Ana", 10, 92)
True
>>> ana._replace(score=95)
Student(name='Ana', grade=10, score=95)
>>> ana._asdict()
{'name': 'Ana', 'grade': 10, 'score': 92}

• Student("Ana", 10, 92) makes one record, like calling any class. Its printed form names every field.
• ana.score reads a field by name. It is still a tuple, so ana[0], unpacking (Day 7), and == with a plain tuple all still work.
• Like any tuple, it cannot change. _replace(field=value) makes a new record with one field changed. _asdict() gives the fields as a dictionary. The leading underscore is only there so these method names cannot clash with your field names.

from collections import namedtuple

Student = namedtuple("Student", ["name", "grade", "score"])

students = [
    Student("Ana", 10, 92),
    Student("Ben", 11, 78),
    Student(name="Chloe", grade=10, score=85),
]

best = max(students, key=lambda student: student.score)
print(f"Top score: {best.name} with {best.score}")

for student in sorted(students, key=lambda student: student.score):
    print(student.name, student.score)

tenth = [student.name for student in students if student.grade == 10]
print("Grade 10:", tenth)

Top score: Ana with 92
Ben 78
Chloe 85
Ana 92
Grade 10: ['Ana', 'Chloe']

namedtuple fields have no type hints. If you want hints, the typing module (Day 19) offers a class form, written like a data class:

from typing import NamedTuple


class Student(NamedTuple):
    name: str
    grade: int
    score: int


ana = Student("Ana", 10, 92)
print(ana, ana.score)

Student(name='Ana', grade=10, score=92) 92

from collections import namedtuple

Student = namedtuple("Student", ["name", "grade", "score"])

ana = Student("Ana", 10, 92)
ana.score = 95
print(ana)

AttributeError: can't set attribute

Day 6 kept a deli queue in a list, serving each customer with pop(0). That works, but it gets slow as the list grows. A list stores its items in one row of numbered slots. Removing slot 0 means moving every other item one place to the left so that the numbering still starts at 0: with 100,000 people waiting, one pop(0) moves 99,999 items. Adding at the front with insert(0, item) does the same, the other way. Only the end of a list is cheap to change.

A deque (from collections, pronounced “deck”, short for “double-ended queue”) is built so that both ends are cheap. Adding or removing at either end takes the same short time, however long it is.

>>> from collections import deque
>>> line = deque(["Ana", "Ben"])
>>> line.append("Chloe")
>>> line.appendleft("Dev")
>>> line
deque(['Dev', 'Ana', 'Ben', 'Chloe'])
>>> line.popleft()
'Dev'
>>> line.pop()
'Chloe'
>>> line
deque(['Ana', 'Ben'])
>>> line[0]
'Ana'
>>> len(line)
2

len, in, for loops, and indexing work on a deque as on a list. A deque gives up fast access to the middle in return for fast ends, so use it for queues, and a list when you mostly read by position.

from collections import deque

waiting = deque(["Ana", "Ben", "Chloe"])
served = 0

while waiting:
    customer = waiting.popleft()
    served += 1
    print(f"Serving {customer}; {len(waiting)} still waiting")
    if customer == "Ana":
        waiting.append("Dev")

print("Served", served, "customers")

Serving Ana; 2 still waiting
Serving Ben; 2 still waiting
Serving Chloe; 1 still waiting
Serving Dev; 0 still waiting
Served 4 customers

A deque can also have a maxlen, a largest size. When a full deque gets a new item at one end, it drops an item from the other end to make room. That makes “keep only the last few” a one-liner:

from collections import deque

recent: deque[str] = deque(maxlen=3)
for page in ["home", "news", "sport", "weather", "news"]:
    recent.append(page)
    print(list(recent))

['home']
['home', 'news']
['home', 'news', 'sport']
['news', 'sport', 'weather']
['sport', 'weather', 'news']

Once three pages are stored, each append on the right pushes the oldest page out on the left. news appears twice in the history because a deque keeps repeats, like a list. (Printing list(recent) keeps the output short; printing the deque itself would also show maxlen=3.)

from collections import deque

waiting = deque(["Ana", "Ben"])
for _ in range(3):
    print("Serving", waiting.popleft())

Serving Ana
Serving Ben
Traceback (most recent call last):
  ...
IndexError: pop from an empty deque

from collections import deque

orders: deque[int] = deque(maxlen=3)
for number in [101, 102, 103, 104]:
    orders.append(number)
orders.appendleft(100)
print(orders)
print(orders.popleft(), orders.pop(), len(orders))

deque([100, 102, 103], maxlen=3)
100 103 1

The itertools module (“tools for iterators”) holds ready-made building blocks for loops. Day 18 used its islice to take the first few items of an endless generator. Three more answer questions that would otherwise need nested loops:

• chain(a, b, ...) gives every item of a, then every item of b, and so on, as one stream. The iterables can be of different kinds: a list, then a tuple, then a generator.
• combinations(items, r) gives every way to choose r items, where order does not matter: choosing A and B is the same choice as B and A, so only one of them appears.
• permutations(items, r) gives every way to arrange r items, where order matters: A then B is different from B then A. Leave out r to arrange all the items.

Each result is a tuple, and no item is used twice in one result. Like Day 18’s generators, these functions are lazy: they return an iterator that makes each result when the loop asks for it. To look at all the results at once, wrap the call in list().

>>> from itertools import chain, combinations, permutations
>>> morning = ["Ana", "Ben"]
>>> afternoon = ("Chloe", "Dev")
>>> list(chain(morning, afternoon))
['Ana', 'Ben', 'Chloe', 'Dev']
>>> list(combinations("ABC", 2))
[('A', 'B'), ('A', 'C'), ('B', 'C')]
>>> list(permutations("ABC", 2))
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
>>> list(permutations("AB"))
[('A', 'B'), ('B', 'A')]

chain saves building a joined list with + just to loop over it, and it works where + cannot, such as a list followed by a tuple. Three letters give three pairs to choose but six pairs to arrange, because each choice can be arranged two ways.

from itertools import combinations, permutations

teams = ["Lions", "Owls", "Foxes", "Bears"]

print("League: each pair plays once")
for number, pair in enumerate(combinations(teams, 2), start=1):
    print(f"{number}. {pair[0]} v {pair[1]}")

home_and_away = list(permutations(teams, 2))
print("Home and away:", len(home_and_away), "matches")
print("First three:", home_and_away[:3])

League: each pair plays once
1. Lions v Owls
2. Lions v Foxes
3. Lions v Bears
4. Owls v Foxes
5. Owls v Bears
6. Foxes v Bears
Home and away: 12 matches
First three: [('Lions', 'Owls'), ('Lions', 'Foxes'), ('Lions', 'Bears')]

The numbers grow fast: permutations of 10 items has 3,628,800 results. Because the iterator is lazy, looping over it uses almost no memory, but list() would store every result at once. Loop over big results; only list() small ones.

from itertools import combinations

matches = combinations(["Lions", "Owls", "Foxes"], 2)
print("Matches:", len(list(matches)))
for team_a, team_b in matches:
    print(team_a, "v", team_b)
print("Done")

Matches: 3
Done

from itertools import chain, combinations, permutations

toppings = ["ham", "egg", "kale", "corn"]
print(len(list(combinations(toppings, 3))))
print(list(combinations(toppings, 3))[0])
print(len(list(permutations(toppings, 2))))
print(list(chain("ab", [1, 2])))

4
('ham', 'egg', 'kale')
12
['a', 'b', 1, 2]

How long was the longest rainy spell? Which days in a row had the same weather? These questions are about runs: items next to each other that share something. groupby from itertools splits an iterable into runs. For each run it gives a pair: the shared value, called the key, and an iterator over the items in that run.

from itertools import groupby

weather = ["sun", "sun", "rain", "rain", "rain", "sun", "snow"]
for kind, days in groupby(weather):
    print(kind, len(list(days)))

sun 2
rain 3
sun 1
snow 1

sun appears twice in the output, because there are two separate sunny runs. groupby only ever compares an item with the one just before it, so it never looks back to join the two. Each run’s items come as an iterator, so line 5 uses list(days) to collect them before counting them with len.

To group by something other than the item itself, pass key=, a function, as with sorted (Day 10). And to make each group hold every matching item, sort by the same key first, so that matching items sit next to each other:

from itertools import groupby

names = ["Ben", "Ana", "Bea", "Cal", "Abe", "Bo"]
names.sort()
print(names)
for letter, group in groupby(names, key=lambda name: name[0]):
    print(letter, list(group))

['Abe', 'Ana', 'Bea', 'Ben', 'Bo', 'Cal']
A ['Abe', 'Ana']
B ['Bea', 'Ben', 'Bo']
C ['Cal']

groupby shines when the data is already in order, such as log lines in time order (see Putting it together), or when the runs themselves are the point.

from itertools import groupby

names = ["Ben", "Ana", "Bea", "Cal", "Abe", "Bo"]
for letter, group in groupby(names, key=lambda name: name[0]):
    print(letter, list(group))

B ['Ben']
A ['Ana']
B ['Bea']
C ['Cal']
A ['Abe']
B ['Bo']

from itertools import groupby

code = "".join(f"{char}{len(list(run))}" for char, run in groupby("aaabccaa"))
print(code)
longest = max(len(list(run)) for char, run in groupby("xxyyyyxz"))
print(longest)

a3b1c2a2
4

Day 13 met the datetime module’s three main types: date for a calendar day, datetime for a day and a time, and timedelta for a length of time. Add a timedelta to a date and you get a new date; subtract two dates and you get a timedelta. Real programs are built on exactly that arithmetic: due dates, deadlines, shift lengths, ages.

from datetime import date, timedelta

LOAN_DAYS = 21
FINE_PER_DAY = 0.25


def due_date(borrowed: date) -> date:
    """Return the day a book borrowed on the given day is due back."""
    return borrowed + timedelta(days=LOAN_DAYS)


def fine(borrowed: date, returned: date) -> float:
    """Return the late fine in dollars, or 0.0 if the book is on time."""
    days_late = (returned - due_date(borrowed)).days
    return max(0, days_late) * FINE_PER_DAY


borrowed = date(2026, 2, 10)
print("Due back:", due_date(borrowed))
print(f"Returned 1 March: ${fine(borrowed, date(2026, 3, 1)):.2f}")
print(f"Returned 10 March: ${fine(borrowed, date(2026, 3, 10)):.2f}")

Due back: 2026-03-03
Returned 1 March: $0.00
Returned 10 March: $1.75

Notice that neither function asks the computer what day it is. A real library program would call fine(borrowed, date.today()), with date.today() from Day 13. Passing the date in as a parameter, instead of calling date.today() inside the function, keeps the function repeatable: it gives the same answer for the same arguments on any day, so the examples on this page print the same output every time, and a test (Day 20) can check a fine for any return date without waiting for that date to come. The same goes for datetime.now().

Dates and datetimes can also be compared with <, >, and ==: earlier is smaller. And a datetime can be split into its date() and its time():

from datetime import datetime

start = datetime(2026, 3, 6, 22, 30)
end = datetime(2026, 3, 7, 6, 15)
shift = end - start
print(shift)
print(shift.total_seconds() / 3600, "hours")
print(end > start, end.date(), end.time())

7:45:00
7.75 hours
True 2026-03-07 06:15:00

A night shift from 10:30 p.m. to 6:15 a.m. the next morning is 7 hours 45 minutes; subtracting the datetimes handles the midnight in between. Printing a timedelta shows hours, minutes, and seconds. total_seconds() gives the whole length in seconds, as a float, so dividing by 3600 (seconds in an hour) gives hours: 27,900 / 3600 = 7.75.

>>> from datetime import timedelta
>>> trip = timedelta(days=1, hours=2)
>>> trip
datetime.timedelta(days=1, seconds=7200)
>>> trip.seconds
7200
>>> trip.total_seconds()
93600.0
>>> trip.total_seconds() / 3600
26.0

from datetime import date, datetime, timedelta

print(date(2028, 2, 27) + timedelta(days=3))
print(datetime(2026, 5, 1, 23, 50) + timedelta(minutes=25))
print((date(2026, 12, 25) - date(2026, 12, 1)).days)

2028-03-01
2026-05-02 00:15:00
24

People write dates in many ways: 11/05/2026, May 11, 2026, 2026-05-11. A program needs two conversions. Formatting turns a date into text in the layout you choose. Parsing does the reverse: it reads text and builds a date from it.

Day 13 introduced strftime (“string from time”) for formatting. Its codes, each starting with %, stand for parts of a date or time:

>>> from datetime import date, datetime
>>> exam = datetime(2026, 5, 11, 8, 0)
>>> exam.strftime("%A %d %B %Y")
'Monday 11 May 2026'
>>> exam.strftime("%a %b %d, %I:%M %p")
'Mon May 11, 08:00 AM'
>>> f"Exam day: {exam:%d/%m/%Y}"
'Exam day: 11/05/2026'
>>> exam.isoformat()
'2026-05-11T08:00:00'
>>> date.fromisoformat("2026-05-11")
datetime.date(2026, 5, 11)
>>> datetime.strptime("11/05/2026 08:00", "%d/%m/%Y %H:%M")
datetime.datetime(2026, 5, 11, 8, 0)

• strftime keeps every character that is not a code, such as spaces, commas, and slashes, so you build the layout around the codes.
• An f-string can take the same codes after a colon, {exam:%d/%m/%Y}, just like the :.2f format specifier from Day 3.
• isoformat() gives the international standard layout, ISO 8601: year, month, day, from biggest to smallest, with a T before any time. It is the safest layout for files, because it means the same thing in every country, and ISO dates sort correctly as plain text.
• date.fromisoformat(text) parses an ISO date. datetime.strptime(text, format) (“string parse time”) parses any layout, given the codes that describe it, and returns a datetime.

from datetime import date, datetime


def read_us_date(text: str) -> date | None:
    """Return the month/day/year date in text, or None if there is none."""
    try:
        return datetime.strptime(text, "%m/%d/%Y").date()
    except ValueError:
        return None


for text in ["3/14/2026", "12/1/2026", "14/3/2026", "2/30/2026"]:
    when = read_us_date(text)
    if when is None:
        print(text, "is not a month/day/year date")
    else:
        print(text, "is", when.isoformat(), f"({when:%A})")

3/14/2026 is 2026-03-14 (Saturday)
12/1/2026 is 2026-12-01 (Tuesday)
14/3/2026 is not a month/day/year date
2/30/2026 is not a month/day/year date

Without the try, a bad date stops the program with a message that shows both the text and the format:

from datetime import datetime

when = datetime.strptime("14/3/2026", "%m/%d/%Y")
print(when)

ValueError: time data '14/3/2026' does not match format '%m/%d/%Y'

from datetime import datetime

when = datetime.strptime("03/14/2026", "%M/%d/%Y")
print(when)

2026-01-14 00:03:00

Day 3’s string methods find exact text: note.find("555-0142") finds that one phone number. But what if you want any phone number, any order code, or any email address? You know what they look like (three digits, a dash, four digits) but not what they say. A regular expression, or regex, is a pattern that describes what text looks like. The re module searches text for patterns.

A pattern is a string in which most characters match themselves, and a few have special meanings:

So \d{3}-\d{4} means “three digits, a dash, four digits”, which matches 555-0142 and any other number of that shape.

Patterns use many backslashes, and Day 3 taught that a backslash in a string starts an escape character: "\n" is a line break, and "\b" is a “backspace” character, not \b. To keep every backslash exactly as typed, write patterns as raw strings: put an r before the opening quote. A raw string treats a backslash as an ordinary character.

>>> len("\b"), len(r"\b")
(1, 2)
>>> print(r"\d{3}-\d{4}")
\d{3}-\d{4}

re.search(pattern, text) looks for the first place in text that matches. It returns a match object describing it, or None if nothing matches:

>>> import re
>>> note = "Call Ana at 555-0142 before Friday."
>>> match = re.search(r"\d{3}-\d{4}", note)
>>> match
<re.Match object; span=(12, 20), match='555-0142'>
>>> match.group()
'555-0142'
>>> print(re.search(r"\d{3}-\d{4}", "Call Ana on Friday."))
None

The match object shows its span, where the match starts and stops (as slice positions, Day 3), and the text that matched. group() gives the matched text. Searching a note with no phone number gives None.

import re

messages = [
    "Hi, my order AB-1234 has not arrived.",
    "Order number zz-9999, thanks",
    "Where is CD-0042? It was due Monday.",
]
for message in messages:
    match = re.search(r"([A-Z]{2})-(\d{4})", message)
    if match:
        store = match.group(1)
        number = int(match.group(2))
        print(match.group(), "is store", store, "order", number)
    else:
        print("No order code in:", message)

AB-1234 is store AB order 1234
No order code in: Order number zz-9999, thanks
CD-0042 is store CD order 42

import re

message = "Order number zz-9999, thanks"
code = re.search(r"[A-Z]{2}-\d{4}", message).group()
print(code)

AttributeError: 'NoneType' object has no attribute 'group'

search stops at the first match. Two more functions handle every match at once:

• re.findall(pattern, text) returns a list of every match, as strings. If the pattern has one group, the list holds just that group’s text from each match. (With several groups, it holds a tuple of groups for each match.)
• re.sub(pattern, replacement, text) (“substitute”) returns a new string in which every match is replaced. Strings are immutable (Day 3), so the original text is unchanged.

import re

note = "Paid $12.50 on 3 March, $8.75 on 5 March and $20.00 on 9 March."

print(re.findall(r"\$\d+\.\d{2}", note))
amounts = re.findall(r"\$(\d+\.\d{2})", note)
print(amounts)
print(f"Total: ${sum(float(amount) for amount in amounts):.2f}")

['$12.50', '$8.75', '$20.00']
['12.50', '8.75', '20.00']
Total: $41.25

sub cleans and rewrites text. In the replacement, \1, \2, and so on put back what group 1, group 2, and so on matched, so a raw string is needed there too. And an optional flags=re.IGNORECASE argument makes a pattern ignore the difference between capital and lower-case letters:

>>> import re
>>> re.sub(r"\s+", " ", "too    many   spaces")
'too many spaces'
>>> re.sub(r"\d{4} ", "#### ", "Card 4111 2222 3333 4444")
'Card #### #### #### 4444'
>>> re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\2-\1", "Due 14/03/2026")
'Due 2026-03-14'
>>> re.findall(r"cat", "Cat, cat, CAT, catalog", flags=re.IGNORECASE)
['Cat', 'cat', 'CAT', 'cat']
>>> re.findall(r"\bcat\b", "Cat, cat, CAT, catalog", flags=re.IGNORECASE)
['Cat', 'cat', 'CAT']

• \s+ matches any run of whitespace, so every run becomes one space.
• \d{4} (four digits and a space) matches the first three blocks of the card number, but not the last, which has no space after it.
• The date pattern has three groups, and r"\3-\2-\1" writes them back in the opposite order, turning a day/month/year date into an ISO date.
• With IGNORECASE, cat matches Cat and CAT, and also the cat inside catalog. Adding \b on each side keeps only whole words.

>>> import re
>>> line = 'She said "hello" and then "goodbye".'
>>> re.findall(r'".+"', line)
['"hello" and then "goodbye"']
>>> re.findall(r'"[^"]+"', line)
['"hello"', '"goodbye"']

import re

post = "Loving #Python and #regex! Day #21 of 25. #"
tags = re.findall(r"#(\w+)", post)
print(tags)
print(re.sub(r"#\w+", "[tag]", post))

['Python', 'regex', '21']
Loving [tag] and [tag]! Day [tag] of 25. #

Day 13 read command-line arguments from sys.argv: python greet_args.py Ana put "Ana" at sys.argv[1]. That is fine for one argument. But real commands take options in any order, such as --times 2 or --shout, convert numbers, fill in defaults, explain how to use them, and print a clear message when someone types them wrongly. Doing all that by hand with sys.argv would take dozens of lines. The argparse module does it for you: you describe the arguments, and it reads sys.argv for you.

import argparse

parser = argparse.ArgumentParser(description="Greet someone by name.")
parser.add_argument("name", help="who to greet")
parser.add_argument("-t", "--times", type=int, default=1, help="how often")
parser.add_argument("--shout", action="store_true", help="greet in capitals")
args = parser.parse_args()

greeting = f"Hello, {args.name}!"
if args.shout:
    greeting = greeting.upper()
for _ in range(args.times):
    print(greeting)

HELLO, ANA!
HELLO, ANA!

You also get a help message for free. Run python greet.py --help (or -h):

usage: greet.py [-h] [-t TIMES] [--shout] name

Greet someone by name.

positional arguments:
  name               who to greet

options:
  -h, --help         show this help message and exit
  -t, --times TIMES  how often
  --shout            greet in capitals

The first line is the usage summary: square brackets mark what is optional, and name is required. Each help= text from lines 4 to 6 appears beside its argument. This is Python 3.14’s layout; older versions may differ a little, for example saying optional arguments: instead of options:.

When the arguments are wrong, argparse prints the usage line and an error, and stops the program before your code runs. Run with no name at all:

usage: greet.py [-h] [-t TIMES] [--shout] name
greet.py: error: the following arguments are required: name

Typing -t two stops it the same way, with a message that 'two' is not a valid int. Compare Day 13’s greet_args.py, which had to check len(sys.argv) itself.

parse_args() can also take a list of strings in place of the real command line, as in parser.parse_args(["Ana", "--times", "3"]). That is how you try a parser out, or test it (Day 20), without typing commands.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--max-price", type=float, default=50.0)
args = parser.parse_args(["--max-price", "20"])
print(args)
print(args.max-price)

Namespace(max_price=20.0)
AttributeError: 'Namespace' object has no attribute 'max'

Every module today replaced code you could have written yourself, and every one of them has been written, tested by thousands of programmers, and fixed when someone found an edge case. Code you do not write is code you do not have to test or debug. So before you write a utility, spend two minutes looking for it:

• Read the list of modules in the Python Standard Library documentation. Even skimming the names teaches you what exists.
• Search the web for “python standard library” and the job, such as “python standard library median”.
• In the REPL, help(module) shows a module’s documentation, and dir(module) lists its names (Day 13).

Some small finds that replace earlier days’ practice:

>>> import calendar
>>> calendar.isleap(2024), calendar.isleap(2100)
(True, False)
>>> import statistics
>>> scores = [72, 88, 95, 88]
>>> statistics.mean(scores), statistics.median(scores), statistics.mode(scores)
(85.75, 88.0, 88)
>>> import string
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

calendar.isleap is Day 4’s leap year rule, including the rule that 2100 is not a leap year. statistics has the averages: the mean adds the scores and divides (343 / 4 = 85.75), the median is the middle value of the sorted scores (halfway between 88 and 88), and the mode is the most common value. string has ready-made strings of letters, digits, and punctuation.

Writing a utility yourself is still worth doing once, to learn how it works, as you did on Days 4 and 8. In a real program, reach for the library.

A web server writes one line per visit: the date and time, the kind of request, the page, and a status code (200 means it worked; 400 or more means an error). This command summarizes a log file. It uses one tool from each of today’s modules:

"""Summarize a web server's visit log."""

import argparse
import re
from collections import Counter, deque, namedtuple
from datetime import datetime
from itertools import groupby

Visit = namedtuple("Visit", ["when", "page", "status"])
LINE_PATTERN = r"^(\S+ \S+) (GET|POST) (\S+) (\d{3})$"


def read_visits(path: str) -> list[Visit]:
    """Return the visits in a log file, skipping lines that are not visits."""
    visits: list[Visit] = []
    with open(path, encoding="utf-8") as file:
        for line in file:
            match = re.search(LINE_PATTERN, line.strip())
            if match:
                when = datetime.strptime(match.group(1), "%Y-%m-%d %H:%M:%S")
                visits.append(Visit(when, match.group(3), int(match.group(4))))
    return visits


def main() -> None:
    parser = argparse.ArgumentParser(description="Summarize a visit log.")
    parser.add_argument("logfile", help="the log file to read")
    parser.add_argument("--top", type=int, default=3, help="pages to list")
    args = parser.parse_args()

    visits = read_visits(args.logfile)
    span = visits[-1].when - visits[0].when
    hours = span.seconds // 3600
    print(f"{len(visits)} visits over {span.days} days and {hours} hours")

    for day, group in groupby(visits, key=lambda visit: visit.when.date()):
        print(f"{day:%a %d %b}: {len(list(group))} visits")

    pages = Counter(visit.page for visit in visits)
    for page, count in pages.most_common(args.top):
        print(page, count)

    errors: deque[Visit] = deque(maxlen=2)
    for visit in visits:
        if visit.status >= 400:
            errors.append(visit)
    for visit in errors:
        print(f"Error {visit.status} on {visit.page} at {visit.when:%H:%M}")


if __name__ == "__main__":
    main()

The log file, visits.txt, in the same folder:

2026-03-02 09:15:02 GET /home 200
2026-03-02 09:15:40 GET /menu 200
2026-03-02 11:02:13 POST /order 500
2026-03-03 08:30:00 GET /home 200
2026-03-03 08:31:12 GET /menu 200
2026-03-03 08:33:57 GET /menus 404
this line is not a visit
2026-03-04 18:45:30 GET /home 200
2026-03-04 18:47:05 POST /order 200

Run with python log_report.py visits.txt --top 2:

8 visits over 2 days and 9 hours
Mon 02 Mar: 3 visits
Tue 03 Mar: 3 visits
Wed 04 Mar: 2 visits
/home 3
/menu 2
Error 500 on /order at 11:02
Error 404 on /menus at 08:33

span.seconds // 3600 is 34,323 seconds (9 hours, 32 minutes, 3 seconds) divided by 3600 and rounded down: 9 hours. The line this line is not a visit has no time, so the pattern does not match it, and the file’s eight real visits are all counted. Without the standard library, this program would need a hand-written counting loop, a grouping loop, a date parser that knows each month’s length, string slicing to pull each line apart, and code to read sys.argv and print a usage message.

Use this table to go from a message to its usual cause. Older versions of Python may word some messages differently.

• The standard library comes with Python. Before writing a utility, look for it there: library code is already written and tested.
• collections has Counter for counting (most_common, a missing item counts as 0), defaultdict for grouping and totals without checking for missing keys, namedtuple for small fixed records with named fields, and deque for queues that are fast at both ends, with maxlen to keep only the last few items.
• itertools has chain to join iterables, combinations to choose items where order does not matter, permutations to arrange them where it does, and groupby to split data into runs, after sorting it by the same key. All return lazy iterators.
• datetime does calendar arithmetic (date - date is a timedelta; use total_seconds() for exact lengths), formats with strftime codes, and parses with strptime or fromisoformat. Pass “today” into functions so they stay repeatable.
• A regular expression describes what text looks like. With re, search finds the first match (or None), findall lists all of them, and sub replaces them. argparse reads positional arguments, options, and flags, and writes the help and error messages for you.

Do these in your day21 folder. Type each program yourself, run it, and only then open the answer.

The garden was quiet in the morning. The bees came first, and then the birds.
A bee does not stop for long: it visits a flower, takes what it needs, and
moves on to the next flower. The birds were louder. They argued over the
feeder, and the smallest bird always seemed to win. By noon the garden was
warm, the bees were busy, and the birds had gone quiet in the shade. In the
evening the garden belonged to the moths.

import re
from collections import Counter
from pathlib import Path


def top_words(text: str, how_many: int) -> list[tuple[str, int]]:
    """Return the most common words in text, with their counts.

    Words are compared in lower case, and punctuation is ignored.
    """
    words = re.findall(r"[a-z']+", text.lower())
    return Counter(words).most_common(how_many)


text = Path("story.txt").read_text(encoding="utf-8")
for word, count in top_words(text, 10):
    print(word, count)

the 15
and 4
garden 3
in 3
birds 3
to 3
was 2
quiet 2
bees 2
a 2

from datetime import date

TODAY = date(2026, 10, 15)


def days_until(target: date, today: date) -> int:
    """Return how many days from today until target (negative if past)."""
    return (target - today).days


def ask_for_date(prompt: str) -> date:
    """Keep asking until the user types a real date as YYYY-MM-DD."""
    while True:
        text = input(prompt)
        try:
            return date.fromisoformat(text)
        except ValueError:
            print(f"{text} is not a date like 2026-12-25. Try again.")


target = ask_for_date("Date (YYYY-MM-DD): ")
days = days_until(target, TODAY)
if days > 0:
    print(f"{target:%A %d %B %Y} is {days} days away.")
elif days == 0:
    print("That is today!")
else:
    print(f"{target:%A %d %B %Y} was {-days} days ago.")

Date (YYYY-MM-DD): next friday
next friday is not a date like 2026-12-25. Try again.
Date (YYYY-MM-DD): 2026-02-30
2026-02-30 is not a date like 2026-12-25. Try again.
Date (YYYY-MM-DD): 2026-12-25
Friday 25 December 2026 is 71 days away.

import re

EMAIL_PATTERN = r"[\w.+-]+@[\w-]+\.[\w.-]*\w"


def find_emails(text: str) -> list[str]:
    """Return every email address in text, in the order they appear."""
    return re.findall(EMAIL_PATTERN, text)


notice = """Questions about the trip? Email ana.lee@example.com or
call the office. Tickets: tickets+trip@mail.example.org. Our old
address, info@example.net, still works. (Do not write to @school
or to someone@ with nothing after it.)"""

for email in find_emails(notice):
    print(email)

ana.lee@example.com
tickets+trip@mail.example.org
info@example.net

from collections import defaultdict

by_letter = defaultdict([])
by_letter["A"].append("Ana")
print(by_letter)

TypeError: first argument must be callable or None

by_letter = defaultdict(list)

from collections import Counter, namedtuple
from itertools import groupby

Sale = namedtuple("Sale", ["day", "item"])
sales = [
    Sale("Mon", "tea"),
    Sale("Mon", "cake"),
    Sale("Tue", "tea"),
    Sale("Mon", "tea"),
]
for day, group in groupby(sales, key=lambda sale: sale.day):
    print(day, [sale.item for sale in group])
print(Counter(sale.item for sale in sales).most_common(1))

Mon ['tea', 'cake']
Tue ['tea']
Mon ['tea']
[('tea', 3)]

import re

schedule = "Doors 9:05, talks at 10:30 and 14:30, room 101. Ends 17:45."
print(re.findall(r"\b\d{1,2}:\d{2}\b", schedule))

['9:05', '10:30', '14:30', '17:45']

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("name")
parser.add_argument("--times", default=1)
args = parser.parse_args(["Ana", "--times", "3"])
for _ in range(args.times):
    print(f"Hello, {args.name}!")

TypeError: 'str' object cannot be interpreted as an integer

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("name")
parser.add_argument("--times", type=int, default=1)
args = parser.parse_args(["Ana", "--times", "3"])
for _ in range(args.times):
    print(f"Hello, {args.name}!")

Hello, Ana!
Hello, Ana!
Hello, Ana!

def is_overdue(due: date, today: date) -> bool:
    """Return True if today is after the due date."""
    return today > due

The Python Tutorial’s Brief Tour of the Standard Library and Part II show more modules in the same spirit. When you write regular expressions often, the Regular Expression HOWTO goes much further than today.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can count items with Counter and list the most common ones. Reread
• I can group and total values with defaultdict, and explain why reading a key can add it. Reread
• I can make a small record with namedtuple and read its fields by name. Reread
• I can use a deque as a queue, and keep only the last few items with maxlen. Reread
• I can join iterables with chain, and choose between combinations and permutations. Reread
• I can split data into runs with groupby, sorting it first when needed. Reread
• I can add and subtract dates and times, and pass "today" into a function. Reread
• I can format a date with strftime and parse one with strptime. Reread
• I can write a regular expression and find a match with re.search. Reread
• I can list every match with re.findall and replace matches with re.sub. Reread
• I can read positional arguments, options, and flags with argparse. Reread
• I can look in the standard library before writing a utility myself. Reread