THE ROADMAP

Five stages from syntax to systems.

Each stage has a concrete outcome and project. Complete lessons in sequence, or use the map to identify the exact gap you need to close.

STAGE 01

Foundations

0% complete
0%

Outcome: Choose data structures, control flow, iteration tools, and function signatures.

Stage project: Build a typed expense-summary CLI.

  1. Syntax and ValuesUnderstand expressions, names, core value types, identity, equality, and mutability.
  2. Operators and ConditionalsCompute, compare, combine conditions, and choose branches with clear Python logic.
  3. Strings and Built-insCreate and transform Unicode text while using Python's essential built-in functions.
  4. Lists and TuplesModel ordered data with mutable lists and fixed-shape immutable tuples.
  5. Dictionaries and SetsUse mappings for keyed lookup and sets for unique membership and set algebra.
  6. IterationLoop over iterables, pair and transform data, build comprehensions, and sort by keys.
  7. FunctionsDesign reusable functions with clear inputs, outputs, scope, documentation, and errors.
  8. Arguments and UnpackingMaster parameter kinds, defaults, variadic calls, and iterable or mapping unpacking.

STAGE 02

Core language

0% complete
0%

Outcome: Design classes, protocols, decorators, iterators, and typed package boundaries.

Stage project: Build an extensible plugin-driven task engine.

  1. Modules, packages, and importsUnderstand import execution, package boundaries, __init__.py, __all__, re-exports, and stable public APIs.
  2. Classes and object-oriented designDesign cohesive Python objects, choose composition over inheritance, and recognize when a class is unnecessary.
  3. The data model and magic methodsIntegrate custom objects with Python through attribute access, representation, equality, hashing, containers, and operators.
  4. Reusable abstractions, ABCs, and protocolsDefine minimal behavioral contracts with functions, composition, abstract base classes, and structural typing.
  5. Decorators and closuresCapture lexical state, build correct wrappers, preserve metadata, and choose explicit alternatives when wrapping hides too much.
  6. Type hints and annotationsModel precise contracts with modern unions, generics, protocols, narrowing, and postponed annotation evaluation.
  7. Exceptions and context managersDesign explicit failure boundaries, preserve exception context, aggregate concurrent errors, and guarantee resource cleanup.
  8. Comprehensions, iterators, and generatorsBuild correct lazy pipelines by understanding iterable protocols, one-shot iterators, generator control flow, and readable comprehensions.

STAGE 03

Software engineering

0% complete
0%

Outcome: Structure, debug, profile, configure, and evolve maintainable Python systems.

Stage project: Package and benchmark a command-line application.

  1. PEP 8 and clean PythonUse consistent style, clear names, and small units without turning code into code golf.
  2. Project structure and boundariesBuild installable Python packages with a src layout and explicit separation of concerns.
  3. Reusable designReduce duplication carefully and choose functions or objects based on state and variation.
  4. Algorithms and complexityDesign algorithms systematically and use Big-O to reason about growth and tradeoffs.
  5. Searching and sortingSelect reliable search and sort techniques using Python's built-ins and clear invariants.
  6. Configuration and loggingLoad validated settings from TOML and the environment, then emit structured operational evidence.
  7. Debugging and profilingReproduce failures, inspect state with pdb, and profile before changing performance-sensitive code.
  8. Command-line applicationsBuild testable CLIs and choose between argparse and Typer according to project needs.
  9. Dependency decisionsApply a rigorous framework when choosing between the Python standard library and external packages.

STAGE 04

Standard library & async

0% complete
0%

Outcome: Select standard modules and coordinate concurrent I/O with safe cancellation.

Stage project: Build a rate-limited asynchronous URL monitor.

  1. os and sysWork with operating-system services and the running Python interpreter.
  2. Paths and filesCompose paths, manage resources, and update files safely with pathlib.
  3. Datetime and timezone correctnessModel instants, local times, durations, and daylight-saving transitions correctly.
  4. Math and statisticsSelect numeric representations and compute descriptive statistics safely.
  5. HTTP with urllibBuild URLs and make dependency-free synchronous HTTP requests safely.
  6. Collections and itertoolsUse specialized containers and compose lazy iterator pipelines.
  7. Asyncio foundationsUnderstand coroutines, tasks, the event loop, and cooperative scheduling.
  8. Structured concurrencyOwn task lifetimes with TaskGroup, gather, cancellation, and timeouts.
  9. Synchronization and race conditionsProtect invariants with locks, semaphores, events, conditions, and queues.
  10. Standard library quick referenceA selection map for common APIs, tradeoffs, pitfalls, and further practice.

STAGE 05

Tooling, web & data

0% complete
0%

Outcome: Test, package, persist, serve, and analyze production-oriented Python applications.

Stage project: Ship a tested API with SQL storage and an analytics report.

  1. uv, pip, and packagingCreate reproducible environments, define pyproject metadata, and ship importable Python packages.
  2. Ruff, Black, and mypyAutomate formatting, linting, import hygiene, and static type checking without tool overlap.
  3. pytest fundamentalsWrite expressive tests with fixtures, parametrization, temporary resources, and boundary-focused mocks.
  4. Coverage that finds riskMeasure statements and branches with pytest-cov, interpret missing paths, and set useful coverage policy.
  5. Requests and HTTPXBuild defensive synchronous and asynchronous HTTP clients with explicit timeouts and useful errors.
  6. Build typed APIs with FastAPIDesign validated FastAPI endpoints with dependency injection, explicit errors, and testable boundaries.
  7. SQL databases in PythonUse sqlite3 and SQLAlchemy safely with parameters, explicit transactions, and deliberate abstraction.
  8. NumPy arrays and vectorizationWork confidently with array shapes, dtypes, broadcasting, vectorized operations, and numerical pitfalls.
  9. Pandas for tabular dataSelect, clean, aggregate, and join labeled tables while preserving types and row meaning.
  10. Testing strategyBalance unit, integration, contract, and end-to-end tests around risk and feedback speed.
  11. Capstone — civic data trackerBuild a packaged CLI and FastAPI service with a transactional database, data imports, and layered tests.