◀ Your progress Course contents

Course contents

Part 1

First Steps

6 Modules

Everything you need to write a small program that works: printing, naming things, the handful of value types Python has, text, input, and arithmetic. No prior experience assumed, and nothing skipped.

1

Hello, Python

Write and run your first program, make it speak with print(), leave notes with comments, and learn to read an error instead of panicking at it.

print() Comments Tracebacks
2

Variables & Names

Store a value under a name so you can use it again, change it later, and describe what it means to the next person who reads the code.

Assignment Naming Reassignment
3

Numbers, Text & Booleans

Python's four everyday value types, how to tell which one you have, and how to convert between them on purpose rather than by accident.

int & float str & bool Conversion
4

Working with Text

Cut, join, search, clean and reshape text with the string methods you will reach for every day, and format results with f-strings.

Slicing Methods f-strings
5

Input & Output

Ask a person a question, take their answer, turn it into the right kind of value, and hand back a result they can actually read.

input() int() & float() Formatting
6

Math & Comparisons

Arithmetic including the two division operators everybody trips over, comparisons that produce True or False, and the order Python does things in.

// and % Comparisons and / or / not
Part 2

Logic & Collections

6 Modules

The point where a program stops being a list of instructions. Deciding, repeating, and the four containers Python leans on for everything it remembers.

1

Making Decisions

if, elif and the indentation that makes a block — plus the branch that can never run, which is the most common bug in conditional code and raises nothing.

if / elif / else Guard clauses Truthiness
2

for Loops

Say the work once and apply it to everything. Walking sequences, counting with range(), and the accumulator shape behind almost every total you will ever write.

range() Accumulators break / continue
3

while Loops

Repeating when you do not know how many times. Validation loops, retry with backoff, and two exercises that run forever on purpose so you have watched an infinite loop rather than been told about one.

Conditions Sentinels Backoff
4

Lists

Many values under one name, and the two bugs only a changeable thing can have: a backup that was never a backup, and a filter that misses half of what it should catch.

append & pop sort vs sorted Aliasing
5

Dictionaries

Looking things up by name instead of by position — the shape every JSON response, config file and database row arrives in, and the counting pattern that replaces a row of separate variables.

Keys & values .get() Counting
6

Tuples & Sets

Two containers chosen for what they refuse to do: one that cannot be edited, and one that keeps no order and no duplicates. Unpacking, and "what changed" as a single operator.

Unpacking Deduplication Set operations
Part 3

Building Blocks

6 Modules

Where programs stop being one long file. Naming pieces of work, handling what goes wrong on purpose, using code other people wrote, and reading and writing real files.

1

Functions

Give a piece of work a name so the code above can talk about it. From here the lab checks call your functions, with values the exercise never showed you.

def & return Early return Docstrings
2

Arguments & Scope

What you can pass and in what order, and the three ways a function quietly stops being repeatable — a shared default, a global, and an argument edited underneath its caller.

*args / **kwargs Mutable defaults Local vs global
3

Comprehensions

The loop-and-append shape on one line — and the two very different places an if can go, which is the mistake that gives you a result of the wrong length rather than an error.

Filtering dict & set Generators
4

Errors & Exceptions

Failing in a way somebody can act on — and the far more common mistake in the other direction, where a handler turns a loud failure into a wrong answer nobody notices.

try / except raise finally
5

Modules & the Standard Library

Most of what you need is already installed. Dates, JSON, statistics, Counter, defaultdict — and two loops from earlier stages replaced by a single call.

import datetime & json collections
6

Reading & Writing Files

A real filesystem in the tab. Opening safely, reading without loading a gigabyte, and the mode that empties your file the moment it is opened.

with open() pathlib Read / transform / write
Part 4

Real Python

6 Modules

Modelling a problem rather than scripting one. Classes and dataclasses, lazy pipelines, the syntax the language gained in the last five years, and a finished tool at the end of it.

1

Classes & Objects

For when data and the things you do to it keep travelling together — and the honest test for when a class was never needed at all.

__init__ & self __repr__ & __eq__ Properties
2

Dataclasses & Type Hints

Say the shape once and have Python write the rest. Plus the one place in the language that refuses the shared-mutable trap outright, before your program runs.

@dataclass frozen & order Annotations
3

Iterators & Generators

What a for loop has been doing all along, a function that pauses instead of returning, and the bug that produces empty output with no traceback at all.

yield Laziness Pipelines
4

Modern Python

The additions worth adopting — and three bugs they exist to kill, including the lstrip that turns staging_server.log into erver.log.

Walrus match / case strict zip
5

Working with Data

Read a file, work out what is wrong with it, reshape what is left, and write something somebody can act on. No extra libraries needed for any of it.

csv & DictReader Group & pivot Missing values
6

Capstone: Your First Sprint

No lesson and no new syntax — a mock engineering job instead. A messy daily CSV export, four colleagues describing what they need in plain English, and fifteen programs between Monday and the tool going into cron on Friday.

Case study Colleague requests Shipping a tool