2. Installing Python and an editor
Install Python 3.14, confirm which version runs, and open a project in an editor.
Python 3.14 installed, python –version printing 3.14.x, and Visual Studio Code opening the tracker folder
stubPython
What this covers
Section titled “What this covers”This is a complete course in Python, taught from zero as the first programming language you learn properly. It teaches the Python language to the depth a professional Python engineer needs in any area: backend, data, AI and automation. Each concept is first explained as a general question that every programming language must answer, and then as Python’s answer. That way, what you learn here carries over to the next language.
The course also teaches the tools you need to work without help: the terminal, installing Python, an editor, virtual environments and automated tests.
One project runs through the whole course: a command-line expense tracker that you build from an empty folder and keep.
What this course does not cover. Libraries and frameworks built on Python, such as Django, FastAPI, pandas and PyTorch, are separate courses after this one. The same is true of web development and HTTP, databases and SQL, algorithms and data structures as a subject, publishing packages, and git.
The goal. By the end, without AI help and with only the official documentation at docs.python.org open, you will be able to:
- build the expense tracker from an empty folder, with several files, functions and classes, JSON and CSV files, deliberate error handling, its own virtual environment and passing automated tests;
- read 50–100 lines of unfamiliar Python, explain every line, and predict the output before running it;
- take a broken program and its error report, and find and fix the cause within 30 minutes;
- open the first tutorial page of four widely used Python libraries (one each from web backend, data processing, AI and automation) and explain every Python language feature on it;
- learn a standard-library module you have never used from its documentation, and use it correctly within 45 minutes.
Version. The course is checked against Python 3.14.7 (checked on 2026-09-21). Python 3.15 is due on 2026-10-01. The course stays on 3.14, because version 3.15 changes little that a beginner meets, and new releases are safer to adopt after a few months.
Size. 45 modules in 11 parts. The estimated total is about 113 hours, which is an estimate for planning, not a limit. The full outline, with every section and topic, is on the syllabus page.
Transfer
Section titled “Transfer”Nothing transfers in. learner-profile.md records no language you already know, so every module teaches from zero. The ideas that will transfer out to your next language are the general questions each module starts from: how names refer to values, how errors travel, how code is split into modules, how iteration works, and how a program does several things at once.
Modules
Section titled “Modules”Getting started
Section titled “Getting started”Install Python, run code in the interactive interpreter and from script files, and move around the file system from a terminal.
1. The command lineOpen a terminal, move between folders, run programs and read their exit status.a project folder created from the terminal, with a program run inside it and its exit status printed
3. Using the Python interpreter
Run Python code interactively and from files, pass arguments to a script, and ask Python itself for help.
a script run three ways (as a file, with -m, and inspected with -i) that prints the arguments it received
stubPython fundamentals
Section titled “Python fundamentals”Write short programs that read input, calculate with numbers and text, make decisions, repeat work and organise code into functions.
4. Basic syntax
Write and run small programs, read the error report when one fails, and fix syntax errors on your own.
a greeting script that reads a name, with every syntax error it can produce reproduced and fixed
stub5. Variables and data types
Store values in variables and choose and convert between numbers, booleans and None.
a unit-converter script that reads numbers, converts between types and prints rounded results
stub6. Strings
Create, slice, search and format text, and print aligned, rounded output.
a receipt-printing script that formats names and amounts into aligned columns
stub7. Operators and expressions
Predict the result of comparison, boolean, membership and identity expressions before running them.
a set of expressions whose results were predicted in writing, then checked by running them
stub8. Conditional statements: if, elif and else
Make a program choose between several paths depending on its input.
a script that classifies an expense amount into bands and rejects invalid input
stub9. Loops: for and while
Repeat work with for and while loops, and stop a loop early or skip an item.
a number-guessing game with a limited number of attempts and input validation
stub10. Functions
Define functions with parameters and return values, and predict which variable a name refers to.
a module of small functions that calculate totals, averages and category shares for the tracker
stubData structures
Section titled “Data structures”Store and process collections of data with lists, tuples, dictionaries and sets, and predict when a change through one name appears through another.
11. Lists
Build, change, sort and summarise lists of values.
an in-memory list of expenses that can be added to, removed from, sorted and summarised
stub12. Tuples and sequences
Group values into tuples and unpack them into separate names.
functions that return several values as a tuple, called with unpacking
stub13. Dictionaries
Map keys to values, look them up safely and count or group data with the collections module.
a category-to-total summary of the tracker’s expenses
stub14. Sets
Remove duplicates and compare collections with set operations.
a script that finds categories present in one expense file but not another
stub15. Object references and mutability
Predict when changing an object through one name shows up through another, and copy data safely.
five aliasing bugs reproduced, predicted in writing and fixed
stub16. Comprehensions
Build lists, sets and dictionaries from other collections in one readable expression.
the tracker’s summary loops rewritten as comprehensions where that is clearer
stub17. Looping techniques
Loop over indexes, pairs and dictionaries cleanly, and change a collection safely while processing it.
the tracker’s report loops using enumerate(), zip() and items()
stubModules, files and exceptions
Section titled “Modules, files and exceptions”Split a program into modules and packages, read and write text, JSON and CSV files, and handle errors deliberately.
18. Modules and packages
Split a program into modules and packages and control what Python finds when it imports.
the tracker split into several modules inside a package and run with python -m
stub19. Reading and writing files
Read and write text files safely, choose the right encoding and handle missing files.
the tracker saving its expenses to a text file and loading them again
stub20. JSON and CSV files
Load and save structured data as JSON and CSV.
the tracker importing a CSV of expenses and exporting a JSON summary
stub21. Errors and exceptions
Handle expected errors deliberately, raise your own, and let unexpected ones surface with a useful traceback.
the tracker rejecting bad CSV rows with clear messages instead of crashing
stub22. File and directory access
Build file paths, list and search folders, and copy or move files from Python.
the tracker finding every CSV file in a folder and moving processed files into an archive folder
stubObject-oriented programming
Section titled “Object-oriented programming”Model data and behaviour with classes, reuse code through inheritance and composition, and make objects work with Python’s built-in syntax.
23. Classes and objects
Define classes with attributes and methods, and create and use instances of them.
an Expense class and an ExpenseBook class used by the tracker
stub24. Inheritance
Share behaviour between classes with inheritance, and choose composition when it fits better.
expense types that share behaviour through a base class, and the same design rewritten with composition
stub25. Special methods
Make your objects print, compare, add and behave like containers by writing special methods.
a Money class that prints, compares, adds and sorts correctly
stub26. Data classes
Replace hand-written data-holding classes with dataclasses.
the Expense class rewritten as a dataclass
stub27. Enumerations
Represent a fixed set of named values with enum.
an expense-category enum used to validate input
stub28. The match statement
Choose between cases by matching the shape of data with match and case.
a command dispatcher for the tracker’s command-line interface written with match
stubIntermediate Python
Section titled “Intermediate Python”Use iterators, generators, decorators, context managers, functional tools and type hints, and recognise them in any library’s code.
29. Iterators and generators
Write generators that produce values lazily, and explain what a for loop does behind the scenes.
a generator pipeline that streams a large CSV file in constant memory
stub30. Decorators
Pass functions as values, write closures, and write and read decorators.
a @timed and a @retry decorator applied to tracker functions
stub31. Context managers
Use and write context managers that guarantee clean-up code runs.
a timing context manager and a temporary-directory helper for the tracker’s tests
stub32. Functional programming
Transform data with map, filter, functools and operator instead of hand-written loops.
the tracker’s report calculations rewritten with map(), filter(), sort keys and functools.reduce
stub33. Type hints
Annotate code with type hints, check it with a type checker, and read the hints in library code.
the tracker fully annotated and passing a type checker
stubConcurrency
Section titled “Concurrency”Run work concurrently with threads, processes and asyncio, and explain which one fits a task.
34. Threading and multiprocessing
Run I/O-bound work in threads and CPU-bound work in processes, and explain what the global interpreter lock changes.
a script that downloads nothing but simulates slow I/O in a thread pool and heavy calculation in a process pool, with timings
stub35. Asynchronous programming with asyncio
Write async functions, run several of them concurrently, and avoid calls that block the event loop.
an async script that runs several simulated slow tasks concurrently with a limit on how many run at once
stubThe standard library
Section titled “The standard library”Use standard-library modules for dates, text patterns, command-line interfaces and logging, and learn an unfamiliar module from its documentation.
36. Dates and times
Parse, compare, format and do arithmetic with dates and times.
the tracker grouping expenses by month with correctly parsed dates
stub37. Regular expressions
Search, validate and extract text with regular expressions.
a validator for expense descriptions and an extractor for dates in free text
stub38. Command-line interfaces: sys.argv and argparse
Build a command-line interface with options and help text, and exit with the right status.
the tracker’s command-line interface with subcommands and generated –help
stub39. Logging
Record what a program does at the right level, to the console or a file.
the tracker logging skipped rows to a file with levels
stub40. Brief tour of the standard library
Find a standard-library module for a task and learn to use it from its documentation page alone.
a small script built with a standard-library module you had never used, working only from its documentation page
stubEcosystem and tooling
Section titled “Ecosystem and tooling”Work in a virtual environment, install third-party packages, and keep code consistently formatted.
41. Virtual environments and packages
Create a virtual environment, install and pin third-party packages, and describe a project’s dependencies.
the tracker in its own virtual environment with a pinned third-party dependency
stub42. Code style and formatting
Write code that follows PEP 8 and keep it formatted and linted automatically.
the tracker formatted and linted with no warnings
stubTesting and debugging
Section titled “Testing and debugging”Find the cause of a bug methodically with a debugger, and prove code works with automated tests.
43. Debugging
Find the cause of a bug methodically, using tracebacks, print statements and the debugger.
three broken versions of the tracker, each diagnosed and fixed with the debugger
stub44. Testing
Write and run automated tests that check functions, including the errors they should raise.
a test suite for the tracker’s parsing and summary functions that runs green
stubLarger programs
Section titled “Larger programs”Plan, structure, test and finish a multi-module program on your own.
45. Developing a larger application
Plan and build a complete multi-module program from an empty folder.
the finished expense tracker: several modules, classes, JSON and CSV files, error handling, a virtual environment and passing tests
stub