Modules & the Standard Library

import math makes the module available under its own name, so every use says where it came from.

import math
math.sqrt(144)   # 12.0
math.ceil(4.1)   # 5
math.floor(4.9)  # 4

ceil and floor always round the same direction, which is what you want when the question is "how many boxes" rather than "what is the nearest number".

Your task: print the square root of 144, the ceiling of 4.1, the floor of 4.9, and pi to four decimal places:

12.0
5
4
3.1416

from math import ceil, floor brings those two names into your file directly, so calls are shorter.

This reads well when the name is unmistakable and used constantly. It reads badly when the bare name could have come from anywhere — a lone load() tells the next reader nothing.

Your task: a warehouse packs items into boxes of 12. Import ceil and floor directly and work out how many boxes are needed for 100 items, and how many of those are full:

9
8

Nine boxes are needed because the last four items still need one; eight of them are full.

import statistics as stats brings the module in under a name of your choosing.

Worth doing for genuinely long module names, and worth doing only with the abbreviation everyone else uses — an alias nobody recognises is strictly worse than the full name.

mean and median are not the same question. Five salaries of 30, 31, 32, 33 and 200 have a mean of 65 and a median of 32, and only one of those describes what most people earn.

Your task: import statistics under the alias stats and print the mean and median of the scores, then of the salaries:

76.25
79.5
65.2
32

random gives you dice rolls, shuffles and samples. It also gives you code that behaves differently every run, which is impossible to test and unpleasant to debug.

random.seed(n) fixes the starting point, so the same seed produces the same sequence every time. In real code you seed in the test and leave it alone in production.

Your task: seed with 7, then print five dice rolls as a list and a shuffled copy of the queue. With that seed the answers are fixed:

[3, 2, 4, 6, 1]
['test', 'notify', 'deploy', 'build']

Seed once at the top, before either call — the rolls and the shuffle draw from the same sequence.

Months have different lengths, years have different lengths, and every piece of code that assumes otherwise fails eventually in a way nobody traces back.

from datetime import date, timedelta
d = date(2026, 9, 2)
d + timedelta(days=30)      # a date
(later - earlier).days      # a whole number of days

Subtracting two dates gives a duration; .days takes the number out of it. Adding a timedelta gives a date back.

Your task: from 2 September 2026, print the date itself, the date thirty days later, the number of days until Christmas, and the start date formatted as day, short month, year:

2026-09-02
2026-10-02
114
02 Sep 2026

A JSON response is text. json.loads turns it into exactly the dictionaries and lists from Part 2, which is why that module spent so long on nested lookups.

obj = json.loads(raw)      # text  -> Python
text = json.dumps(obj)     # Python -> text

The s means "string". The versions without it read from and write to files, which is the next module.

sort_keys=True on dumps makes the output stable, which matters the moment two runs are compared to each other.

Your task: parse the response, print the quantity, the first tag, and how many tags there are, then print the record back out as text with sorted keys:

3
hot
2
{"name": "tea", "qty": 3, "tags": ["hot", "green"]}

Counter does the whole counts[key] = counts.get(key, 0) + 1 loop from module 2-05, and adds a way to ask for the commonest entries.

from collections import Counter
counts = Counter(levels)
counts.most_common(2)   # [('INFO', 3), ('ERROR', 2)]

It behaves like a dictionary everywhere it matters, with one useful difference: a key it has never seen reads as 0 rather than raising.

Your task: tally the levels, then print the commonest two, the count of INFO, the count of a level that never appeared, and the number of distinct levels:

[('INFO', 3), ('ERROR', 2)]
3
0
3

Collecting things into per-key lists needs a check every time: is there a list under this key yet? defaultdict answers it once, at creation.

from collections import defaultdict
groups = defaultdict(list)
groups["eu"].append("tea")   # the list is created on demand

You hand it the function that makes a default — list, not list(). It calls it when a missing key is first touched.

Your task: group the items by region, then print the groups as an ordinary dictionary, one region's list, and the number of regions:

{'eu': ['tea', 'cup'], 'us': ['mat']}
['tea', 'cup']
2

import math binds the name math to the module. Assign anything else to that name and the module is still loaded and no longer reachable through it.

The error — AttributeError: 'int' object has no attribute 'sqrt' — names the type rather than the mistake, which is why this can take longer to spot than it deserves. The same thing happens at file level: a file of your own called random.py makes the real one unreachable from anywhere in that directory.

Your task: run it, read the error, then rename the variable — leaving the import and the calculation alone — so it prints:

12.0
5