Python Exercises by Difficulty

Beginner exercises use a few familiar operations, such as variables, arithmetic, if statements, loops and print(), and produce a result you can check by eye.

Sample task: a cinema charges £8 per adult and £5 per child, with £2 off the whole booking for members. Write ticket_total(adults, children, member), rejecting negative counts.

def ticket_total(adults, children, member=False):
    if adults < 0 or children < 0:
        raise ValueError("ticket counts cannot be negative")
    total = adults * 8 + children * 5
    if member and total > 0:
        total -= 2
    return total

Short code can still hide an important boundary: should the member discount apply to an empty booking and produce −£2? The total > 0 check answers that. More beginner exercises: convert temperatures, count vowels in a word, print a times table, find the largest number in a list without max(), and check whether a year is a leap year.

Intermediate exercises combine functions, collections and data from outside the program, so several parts must cooperate correctly.

Sample task: given a list of screening records like "Fri,Dune,84" (day, film, tickets sold), return total tickets per film and the best-selling day, skipping malformed lines.

def summarise(lines):
    per_film, per_day, skipped = {}, {}, 0
    for line in lines:
        parts = line.split(",")
        if len(parts) != 3 or not parts[2].strip().isdigit():
            skipped += 1
            continue
        day, film, sold = parts[0].strip(), parts[1].strip(), int(parts[2])
        per_film[film] = per_film.get(film, 0) + sold
        per_day[day] = per_day.get(day, 0) + sold
    return per_film, max(per_day, key=per_day.get), skipped

Difficulty comes from the contracts between pieces: the parser must produce exactly what the counter expects, and bad data must be handled without stopping everything. More intermediate exercises: a word-frequency report from a text file, a JSON settings loader with defaults, and a class that tracks seat bookings with validation.

Advanced exercises ask for design, testing and performance decisions, not just longer code. You decide on interfaces, justify trade-offs and provide evidence such as tests or measurements.

Sample task: build a booking service whose seat availability can come from either an in-memory store (for tests) or a database (in production), with tests that never touch the real database.

from typing import Protocol

class SeatStore(Protocol):
    def available(self, screening: str) -> int: ...
    def reserve(self, screening: str, seats: int) -> None: ...

class MemoryStore:
    def __init__(self, seats):
        self.seats = dict(seats)
    def available(self, screening):
        return self.seats.get(screening, 0)
    def reserve(self, screening, seats):
        self.seats[screening] -= seats

def book(store: SeatStore, screening: str, seats: int) -> bool:
    if seats <= 0 or store.available(screening) < seats:
        return False
    store.reserve(screening, seats)
    return True

The design lets tests pass a MemoryStore while production passes a database-backed class with the same methods. Advanced doesn't mean obscure: the best advanced solutions are clear, tested and explain their decisions. More advanced exercises: a rate-limited API client with retries, a CSV-to-database importer with transactions, and a profiled optimisation of a slow report.

Use feedback to decide when to move up a level:

• The course's Python exercises page filters by topic (chapter), type (fill in the blanks, predict the output, multiple choice) and difficulty, and checks answers instantly with hints and explanations.
• The Python quiz mixes questions across chapters, with relaxed, timed and exam modes.
• Your own tests give feedback on longer exercises: write them before the solution.

A reasonable rule: when you solve most exercises at one level without hints, and can explain why each answer is right, attempt the next level. Scoring highly by repeating the same questions until the answers are memorised isn't the same as fluency; vary the questions, revisit topics after a few days, and turn a solved exercise into a slightly different one of your own.

Task: use the Python exercises page to attempt selected chapter tasks, then extend one into a tested independent solution.

1. Filter to a chapter you finished recently and the "medium" level; complete ten exercises.
2. Pick one you found hard and rewrite it as a function with your own test cases:

def leap_year(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

for year, expected in [(2024, True), (1900, False), (2000, True), (2023, False)]:
    assert leap_year(year) == expected, year
print("leap year rules pass")

The cases include the century exceptions, which is where most leap-year solutions fail. For the worked check, what makes an advanced exercise valuable is design and trade-off decisions with evidence, not simply more lines of code.

Use the interactive Python exercises and Python quiz, then continue with quizzes by chapter and the beginner projects.