The Python Your learning path 🗺️
68 lessons across seven levels, starting before code and ending with a private AI assistant you built yourself. Every lesson has plain-English explanations, examples that run in the page, and exercises with hidden solutions.
Lessons are 100 XP. Puzzles are 60. Projects are 250. Quiz answers are 20 each. Achievements pay bonuses.
Level 0 Base Camp - Never written a line of code? Start here. No Python yet, and that is on purpose.
What a Computer Actually Is
CPU, memory, storage and binary, explained as a very fast and very literal kitchen.
What Programming Actually Is
Algorithms, the three moves every program is made of, and why languages exist.
What Python Is, and Where It Came From
A Christmas project named after a comedy troupe that ended up running the world.
Why Python? An Honest Accounting
What Python is genuinely great at, where it loses, and when to pick something else.
The Terminal, Files and Paths
The black window with the cursor: ten commands, and what a path really is.
Setting Up Your Lab
Install Python and an editor, then run your first real program from a real file.
Level 1 First Words - The whole language in miniature: values, names, decisions, repetition.
Hello, World!
print(), your first program, comments, and why errors are completely normal.
Variables: Naming Things
Labelled boxes for your data, naming rules, and why Python never asks for a type.
Numbers and Maths
Whole numbers, decimals, the two kinds of division, and the great 0.1 + 0.2 scandal.
Text: Strings in Depth
f-strings, slicing, and the twenty string methods that do 90% of real text work.
Talking to the Human
Asking the human a question, and the number-one beginner trap that follows.
True, False and Questions
True, False, comparisons, and the truthiness rules that make Python code short.
Making Decisions
if, elif, else, and why Python makes your indentation part of the language.
Loops That Repeat: while
Repeating until something changes, break and continue, and how to escape a loop that never ends.
Loops That Count: for
for, range and enumerate: walking through things without ever writing a counter again.
Reading Errors Without Fear
Tracebacks decoded, the eight errors you will actually meet, and a repeatable debugging method.
Level 2 The Toolbox - Lists, dictionaries and functions: where Python starts feeling like a superpower.
Lists: Many Things at Once
The workhorse container: ordered, changeable, and the source of one famous surprise.
Tuples and Unpacking
Lists that cannot change, why that is a feature, and the unpacking trick you will use daily.
Dictionaries: Look It Up
Look things up by name instead of position. The most useful container in the language.
Sets: No Duplicates Allowed
Unordered collections with no duplicates, and the fastest way to ask 'have I seen this?'
Nested Data
Lists of dictionaries and dictionaries of lists: the shape all real data arrives in.
Comprehensions
Build a whole list in one line. The most Python-looking thing in Python.
Functions: Naming a Process
Bundle steps under a name. The single most important idea in programming.
Arguments in Depth
Defaults, *args, **kwargs, and the mutable default argument: Python's most famous gotcha.
Scope: Where Names Live
Where names live, why a function cannot see inside another, and the LEGB rule.
Modules and the Standard Library
import, your own modules, __main__, and a guided tour of the batteries Python includes.
Level 3 Real Programs - Files, errors, testing, packaging: the difference between a script and software.
Files: Making Things Last
Reading and writing real files, the with statement, and pathlib instead of string surgery.
Exceptions: Handling Failure
try, except, finally, raising your own, and why bare except is a crime.
JSON and CSV
JSON and CSV: the two formats that carry most of the world's data.
Dates and Times
Dates, times, durations, formatting, and why time zones ruin lives.
Regular Expressions
Pattern matching for text: powerful, ugly, and worth exactly the amount you learn.
Virtual Environments and pip
Virtual environments and pip: how to install other people's code without wrecking your machine.
Command-Line Programs
Turn a script into a proper command-line tool with arguments, flags and help text.
Debugging and Logging
print, breakpoint, and logging: three tools, and knowing which one you need.
Testing
Prove your code works, automatically, forever. The habit that changes everything.
Style, Linting and Type Hints
PEP 8, ruff, black, and type hints: making code that other people (and tools) can read.
Level 4 Pythonic - Objects, generators, decorators: the idioms that make Python code look like Python.
Classes and Objects
Bundle data and the things that act on it into one named thing.
Inheritance and Dunder Methods
Inheritance, composition, dunder methods, and why you should usually prefer the second one.
Dataclasses, Enums and match
Classes that hold data, written in a quarter of the lines. Plus enums and structural match.
Iterators and Generators
yield: produce values one at a time instead of building a list you cannot afford.
Decorators
Wrap a function in another function. The @ symbol you have been seeing everywhere.
Context Managers
The with statement, and how to write your own guaranteed cleanup.
Functional Tools
lambda, map, filter, functools and the functional style, used in moderation.
Type Hints for Real
Type hints that actually pay off: generics, Protocols, Optional, and mypy in anger.
Concurrency: Threads and Processes
Threads, processes and the GIL, explained honestly rather than defensively.
async and await
async and await: thousands of things waiting at once, on one thread.
Level 5 In the Wild - Automation, the web, data, games, hardware: what people actually build.
Automating the Boring Things
Rename 4,000 files, tidy a folder, back things up, and schedule it all to run itself.
The Web: HTTP and APIs
HTTP explained, then calling real APIs with requests: the skill that connects everything.
Web Scraping
Getting data out of web pages, and the ethics and law you need to know first.
Building a Web App
Serve your own pages and your own API, with the standard library and then with FastAPI.
Databases with SQLite
SQLite is built in, is a real database, and is enough for far more than you think.
Data Analysis
NumPy and pandas: the tools that made Python the language of science.
Charts and Visualisation
Turning numbers into pictures, and not lying with them.
Making Games
The game loop, and a playable game in under a hundred lines with pygame.
Desktop Applications
Windows, buttons and menus with tkinter, which is already installed.
Packaging and Shipping
Turn your code into something other people can install, with tests running automatically.
Making Python Fast
Measure first, then fix the right thing, and know when to call Rust.
Security Basics
Secrets, hashing, injection, pickle, and the supply chain. The things that actually bite.
Level 6 Build Your Own Jarvis - The capstone track: assemble a private AI assistant you own end to end.
How Language Models Actually Work
What a language model actually does: tokens, prediction, temperature. No magic.
Your First API Call
Your first real API call, and how to keep your key out of your code and off GitHub.
Conversations and Memory
Give your assistant a memory by resending the conversation. Build a real chat loop.
Streaming Responses
Make replies appear word by word instead of after a long pause. The whole feel changes.
Giving Jarvis Tools
Let Jarvis actually do things: check the weather, do maths, run your code. Tool use.
Teaching Jarvis About You
Make Jarvis answer from your own notes, docs and data, not just its training. RAG.
Giving Jarvis a Voice
Give Jarvis ears and a voice: speech to text, text to speech, and the full loop.
Running Models Locally
Run a capable model entirely on your own machine. Private, free per use, offline.
Assemble Your Jarvis
Put it all together: a real, extensible, personal AI assistant. The capstone.
Cost, Safety and Doing This Well
Cost control, safety, honesty, and using the thing you built responsibly. The graduation lesson.