Python Quest

Tracks

1. 01🐣Foundations — Meeting Python for the First Time

   0/7 lessons

   Variables, types, REPL, your first script

   The first steps. Where you install Python on your machine, open a REPL for the first time, and watch a `print('Hello')` come back. Variables, the four basic types (int / float / str / bool), string formatting, getting input from the user. By the end you'll have written and run your first script — and you'll understand why Python's whitespace matters more than any other language you might have heard of.

   Lesson list (7)

   • 01
     What Is Python — And Why Are We Starting Here?~15 min · python, introduction, interpreted, whitespace, zen-of-python
   • 02
     Installation & Setup — Getting Python on Your Machine~25 min · installation, setup, repl, python-version, pyenv, uv, homebrew, path
   • 03
     The REPL Deep Dive — Beyond `>>> hello`~18 min · repl, ipython, history, completion, underscore, exec-eval
   • 04
     Variables & Assignment — Names, Values, and Identity~22 min · variables, assignment, identity, equality, mutability, references, id, tuple-unpacking
   • 05
     The Four Basic Types — int, float, bool, and the None You'll Meet~22 min · int, float, bool, none, types, decimal, ieee754, truthiness
   • 06
     Strings Deep Dive — f-strings, methods, slicing, Unicode~25 min · str, f-string, format, slicing, unicode, encoding, raw-string, escape
   • 07
     Input, Output, and Running Scripts — Becoming a Real Program~22 min · print, input, sys.argv, stdin, stdout, stderr, main, scripts

   ✓Quiz · 3 questions→

2. 02📦Data — The Four Collections (and friends)

   0/7 lessons

   list / tuple / dict / set + bytes

   Python ships with four collection types you'll reach for every single day: list, tuple, dict, set. This track goes deeper than 'here are the methods.' We cover when to choose tuple over list, why dict became insertion-ordered in 3.7, what frozenset and namedtuple are good for, the comprehension idiom that makes Python feel like Python, and the binary handling primitives (bytes, bytearray, memoryview) that almost every tutorial skips.

   Lesson list (7)

   • 01
     Lists — Python's Default Sequence~22 min · list, indexing, slicing, sequence
   • 02
     List Methods & Mutation Patterns — append vs extend, sort vs sorted~22 min · list, mutation, append, extend, sort
   • 03
     Tuples — Immutability, Unpacking, namedtuple~20 min · tuple, immutable, unpacking, namedtuple
   • 04
     Dicts — Python's Universal Lookup Table~25 min · dict, hash, insertion-order, views
   • 05
     Sets and Frozenset — Math, Membership, Dedup~18 min · set, frozenset, membership, set-math
   • 06
     Comprehensions — list / dict / set / generator~25 min · comprehension, list-comp, dict-comp, generator-expression
   • 07
     Bytes, Bytearray, Memoryview — Binary Handling~22 min · bytes, bytearray, memoryview, encoding, binary

   ✓Quiz · 3 questions→

3. 03🔀Flow — Branching, Looping, Functions

   0/7 lessons

   if / loops / functions / closures / walrus

   How Python decides what to do next. if/elif/else, the match statement (3.10+) and where it actually shines, for and while loops with their *unloved* else clause, how functions work in every shape (positional / keyword / default / *args / **kwargs / keyword-only), lambda, closure, scope, and the walrus operator that everyone hated until they didn't.

   Lesson list (7)

   • 01
     if / elif / else — Branching Done Pythonically~18 min · if, elif, branching, truthiness
   • 02
     match Statement — Structural Pattern Matching (3.10+)~20 min · match, pattern-matching, switch, 3.10
   • 03
     for and while — Loops, the else Clause, and break/continue~20 min · for, while, loop, else-on-loop
   • 04
     Functions — Definition, Arguments, and the Many Kinds of Parameters~25 min · function, def, arguments, kwargs, default
   • 05
     Closures and Scope — LEGB and the Strange Behavior of Inner Functions~22 min · closure, scope, LEGB, nonlocal, global
   • 06
     Iteration Helpers — map, filter, and Why You Probably Won't Use Them~15 min · map, filter, functional, comprehension
   • 07
     The walrus, ternary chaining, and small flow tricks~18 min · walrus, assignment-expression, short-circuit, or-default

   ✓Quiz · 3 questions→

4. 04♾️Iterators — Lazy Sequences That Don't Fit in Memory

   0/7 lessons

   generators / yield / itertools / async iter

   The reason Python can chew through a 10GB file without running out of RAM. The iterator protocol (__iter__ / __next__), generators (yield, yield from, send), the coroutine ancestor of asyncio, async iterators (async for, __aiter__), and the itertools golden patterns — groupby, product, chain, tee, cycle — that turn five lines of nested loops into one expression.

   Lesson list (7)

   • 01
     The Iterator Protocol — __iter__ and __next__~22 min · iterator, protocol, iter, next, StopIteration
   • 02
     Generators — yield Replaces 90% of __next__~22 min · generator, yield, lazy
   • 03
     itertools — The Lazy Iteration Toolbox~25 min · itertools, chain, groupby, tee, product
   • 04
     Generator Expressions vs List Comprehensions — When to Choose~15 min · generator-expression, comprehension, lazy, memory
   • 05
     Async Iteration — async for, __aiter__, __anext__~18 min · async, async-for, async-iter, asyncio
   • 06
     Iterator Patterns — Pipelines and the Pythonic Stream~20 min · pipeline, stream, composition
   • 07
     Iteration — the Pythonic Patterns Recap~12 min · recap, idioms, anti-patterns

   ✓Quiz · 3 questions→

5. 05🎀Decorators — Wrapping Without Inheritance

   0/5 lessons

   @ / functools.wraps / factory / class decorator

   Five lessons on Python's love-it-or-hate-it feature: function wrapping and @ syntax, functools.wraps, factories with arguments, callable class decorators, useful built-ins, and production patterns such as timing, logging, and retry.

   Lesson list (5)

   • 01
     Functions Wrapping Functions — The Decorator Idea~22 min · decorator, wrapper, first-class, @
   • 02
     functools.wraps — Preserving Metadata~15 min · wraps, functools, metadata, introspection
   • 03
     Decorator Factories — Decorators That Take Arguments~22 min · decorator-factory, parameterized, @deco(args), closure
   • 04
     Class Decorators and __call__ — When the Wrapper Needs State~18 min · class-decorator, __call__, stateful-wrapper
   • 05
     Built-in Decorators — @property, @cached_property, @staticmethod, @classmethod~22 min · property, cached_property, staticmethod, classmethod, builtin

   ✓Quiz · 3 questions→

6. 06🏗️OOP — Python's Class Mechanics

   0/7 lessons

   class / dunder / dataclass / Protocol / ABC

   How Python actually does objects. class definition, attribute resolution, properties, dunder methods (__init__, __repr__, __eq__, __hash__, and friends), dataclass with field() / __post_init__ / frozen / kw_only, Protocol for structural typing, ABC for nominal interfaces. The OO Quest covers the *philosophy*; this track covers the *Python mechanics*.

   Lesson list (7)

   • 01
     Defining a Class — class, __init__, self~22 min · class, init, self, instance
   • 02
     Instance vs Class Attributes — and the Mutable Default Trap (Again)~18 min · instance-attribute, class-attribute, mutable-default
   • 03
     Dunder Methods Part 1 — __repr__, __str__, __eq__, __hash__~22 min · dunder, repr, eq, hash
   • 04
     Dunder Methods Part 2 — Operator Overloading and Container Behavior~22 min · dunder, operator-overloading, len, getitem, iter, contains
   • 05
     Inheritance, super(), and Composition over Inheritance~22 min · inheritance, super, composition, subclass
   • 06
     dataclass — Boilerplate Removal Done Right~22 min · dataclass, frozen, kw_only, field, post_init
   • 07
     Protocol vs ABC — Structural and Nominal Typing~20 min · protocol, abc, duck-typing, structural, nominal

   ✓Quiz · 3 questions→

7. 07🧬OOP Advanced — MRO, Mixin, Overload, Metaclass, Descriptor

   0/5 lessons

   MRO / Mixin / overload / metaclass / descriptor

   The deep end in five lessons: multiple inheritance and MRO, cooperative super(), mixins versus composition, singledispatch/typing.overload/match, metaclasses, descriptors, and __slots__.

   Lesson list (5)

   • 01
     Multiple Inheritance and the MRO~22 min · mro, multiple-inheritance, c3, super
   • 02
     Mixins and Composition over Inheritance~18 min · mixin, composition, behavior-injection
   • 03
     Function Overloading Workarounds — singledispatch, overload, Match~18 min · overloading, singledispatch, typing-overload, dispatch
   • 04
     Metaclasses — Classes That Make Classes~22 min · metaclass, type, class-creation, advanced
   • 05
     Descriptors and __slots__ — The Lower-Level Tools~22 min · descriptor, slots, memory, advanced

   ✓Quiz · 3 questions→

8. 08🛡️Errors — Things Will Break, Plan For It

   0/6 lessons

   try / EAFP / context manager / exception group

   Exception handling done right. try/except/else/finally, custom exception classes, the EAFP idiom (Easier to Ask Forgiveness than Permission) and why it beats LBYL in Python, context managers (`with` statement) — both how to use them and how to write your own (__enter__/__exit__ and contextlib.contextmanager), exception groups and `except*` (3.11+), and `raise from` for proper exception chaining.

   Lesson list (6)

   • 01
     try / except / else / finally — All Four Clauses~20 min · try, except, else, finally
   • 02
     EAFP vs LBYL — and Why Python Prefers EAFP~15 min · eafp, lbyl, idiom, ask-forgiveness
   • 03
     Custom Exception Classes — Designing Your Own Error Types~18 min · custom-exception, exception-class, raise
   • 04
     Context Managers — with, __enter__, __exit__~20 min · context-manager, with, enter, exit, cleanup
   • 05
     contextlib — Generators as Context Managers~18 min · contextlib, contextmanager, generator, suppress
   • 06
     ExceptionGroup and except* — Multiple Exceptions at Once~18 min · exceptiongroup, except-star, 3.11, asyncio

   ✓Quiz · 3 questions→

9. 09📁Files & I/O — Talking to the Disk

   0/6 lessons

   pathlib / JSON / CSV / encoding / mmap / streaming

   Text and binary I/O, explicit encoding instead of locale guesses, pathlib, JSON, CSV, tempfile, mmap, and streaming large files. Important writes also need a failure-safe publication boundary.

   Lesson list (6)

   • 01
     open() — Modes, Encoding, and the File Object~20 min · open, file, mode, encoding
   • 02
     pathlib — Object-Oriented Paths~20 min · pathlib, path, os.path
   • 03
     JSON — load, dump, and the Real Gotchas~20 min · json, serialization, encoding
   • 04
     CSV — DictReader, DictWriter, and Quoting~18 min · csv, dictreader, dictwriter, quoting
   • 05
     Encoding — UTF-8 as the recommendation, plus edge cases~15 min · encoding, utf-8, unicode, bom
   • 06
     Streaming, tempfile, and mmap — Beyond Read/Write~18 min · streaming, tempfile, mmap, io

   ✓Quiz · 3 questions→

10. 10🔋Standard Library — Batteries Included

    0/6 lessons

    collections / functools / datetime / re / logging / secrets + hashlib

    A six-lesson map of batteries you will actually use: collections, functools, datetime and zoneinfo, regular expressions, logging, plus random, secrets, hashlib, and uuid.

    Lesson list (6)

    • 01
      collections — deque, Counter, defaultdict, namedtuple~22 min · collections, deque, counter, defaultdict, namedtuple
    • 02
      functools — cache, partial, reduce, wraps~20 min · functools, cache, partial, reduce, lru_cache
    • 03
      datetime — Dates, Times, and Timezones~22 min · datetime, timezone, isoformat, strftime
    • 04
      re — Regular Expressions in Python~22 min · re, regex, match, search, compile
    • 05
      logging — Doing It Right~18 min · logging, logger, handler, formatter
    • 06
      The Rest You'll Meet — random, hashlib, uuid, secrets~18 min · random, hashlib, uuid, secrets

    ✓Quiz · 3 questions→

11. 11🧩Modules & Packaging — Organizing Code That Survives

    0/5 lessons

    import / venv / uv / pyproject / PyPI

    How Python finds and loads code. The import system (relative vs absolute, __init__.py and what it actually does, namespace packages, editable installs), virtual environments (venv, uv, pyenv), package managers (pip, uv, poetry — with opinions), pyproject.toml as the new center of gravity, and how to actually publish a package to PyPI when the time comes.

    Lesson list (5)

    • 01
      import — How Python Finds and Loads Code~22 min · import, module, sys.path, package
    • 02
      Packages, __init__.py, and __main__.py~18 min · package, __init__, __main__, namespace-package
    • 03
      Virtual Environments — venv, uv, and the Modern Setup~18 min · venv, virtualenv, uv, isolation
    • 04
      pyproject.toml — The Modern Project File~18 min · pyproject, build-system, metadata, pip
    • 05
      Distributing Code — PyPI and Wheels~15 min · pypi, wheel, publishing, twine

    ✓Quiz · 3 questions→

12. 12🔷Typing — Annotations That Help You Think

    0/5 lessons

    type hints / TypedDict / Pydantic / generics

    Five lessons on optional but powerful typing: annotations, Literal/Final/ClassVar, TypedDict, TypeVar/Generic/Self, Pydantic runtime validation, and the roles of mypy and pyright.

    Lesson list (5)

    • 01
      Basic Type Hints — Annotations That Help You Think~22 min · type-hints, annotation, Optional, Union
    • 02
      Literal, Final, ClassVar — Precise Constraints~18 min · literal, final, classvar, annotated
    • 03
      TypedDict — Structured Dicts with Types~18 min · typeddict, structured-dict, notrequired
    • 04
      Generics — TypeVar, Generic, Self~22 min · generic, typevar, self, paramspec
    • 05
      Pydantic and Runtime Validation — When Types Get Real~18 min · pydantic, validation, fastapi, runtime

    ✓Quiz · 3 questions→

13. 13⚡Concurrency — Async, Threads, Processes

    0/5 lessons

    asyncio / threading / multiprocessing / GIL

    Choose among asyncio, threads, and processes from the work itself. Learn cancellation and timeouts, the GIL, Python 3.13's experimental free-threaded mode, executors, and process boundaries.

    Lesson list (5)

    • 01
      asyncio Basics — async, await, the Event Loop~22 min · asyncio, async, await, coroutine
    • 02
      Async I/O Patterns — Streaming, Timeouts, Cancellation~20 min · async, stream, timeout, cancellation
    • 03
      Threading and the GIL~18 min · threading, gil, lock, thread
    • 04
      Multiprocessing — True Parallelism for CPU-Bound Work~18 min · multiprocessing, process, parallel, executor
    • 05
      Picking the Right Model — async vs threads vs processes~15 min · picking, io-bound, cpu-bound, patterns

    ✓Quiz · 3 questions→

14. 14🧰Tooling — Tests, Debugger, Profiler, Linter

    0/5 lessons

    pytest / mock / pdb / cProfile / ruff / mypy / pre-commit

    Five lessons on evidence: pytest and mocks, pdb and breakpoint(), ruff and mypy, then cProfile, timeit, and memory measurement. Reproduce first; optimize what the profile proves.

    Lesson list (5)

    • 01
      pytest — Tests Done Right~22 min · pytest, testing, fixture, parametrize
    • 02
      mock and unittest.mock — Faking the World~18 min · mock, patch, monkeypatch, stub
    • 03
      pdb and breakpoint() — Real Debugging~15 min · pdb, breakpoint, debugger
    • 04
      ruff and mypy — Lint and Type Check~18 min · ruff, mypy, lint, type-check
    • 05
      Profiling — cProfile, timeit, and Memory~15 min · profile, cprofile, timeit, memory

    ✓Quiz · 3 questions→

15. 15💻CLI — From Script to Tool

    0/4 lessons

    argparse / click / typer / Rich

    How a one-off script becomes a command-line tool people can install. argparse (in stdlib, often enough), click (the most popular third-party choice), typer (modern, type-hint driven, what cwkPippa uses), and the Rich library for terminal UI that doesn't look like 1995.

    Lesson list (4)

    • 01
      sys.argv and argparse — The Stdlib Way~20 min · sys.argv, argparse, cli
    • 02
      click — Decorator-Style CLIs~18 min · click, cli, decorator
    • 03
      typer — Type Hints as the CLI Spec~18 min · typer, type-hints, cli, modern
    • 04
      Rich — Pretty Terminal Output~15 min · rich, terminal, color, progress

    ✓Quiz · 3 questions→

16. 16🐍Pythonic — Beyond Syntax

    0/5 lessons

    EAFP / duck typing / choosing the Python-shaped tool

    Five lessons on choices beyond syntax: EAFP versus LBYL, duck typing, comprehensions and generators, when not to use a class, dunder protocols, and common non-Pythonic shapes.

    Lesson list (5)

    • 01
      EAFP, Duck Typing, and Trust~18 min · eafp, duck-typing, idiom, trust
    • 02
      Comprehensions, Generators, and the Right Shape~18 min · comprehension, generator, idiom, pythonic
    • 03
      When NOT to Use a Class~15 min · class, function, module, anti-pattern
    • 04
      The Zen of Python — and What It Actually Means~15 min · zen, pep-20, philosophy, style
    • 05
      Anti-patterns — Things to Stop Doing~15 min · anti-pattern, common-mistake, style

    ✓Quiz · 3 questions→

17. 17🌸Epilogue — Python in cwkPippa

    0/1 lessons

    FastAPI / Pydantic / async / pytest — Python in cwkPippa

    One lesson. A walking tour of cwkPippa's Python codebase. FastAPI as the web layer (async at the boundary), Pydantic everywhere for type-safe boundaries, async/await all the way down, pytest as the safety net, and how the patterns from every track in this quest show up — by name — in the code that runs me. The goal: when you finish this lesson, you can read the cwkPippa source and recognize *every line* as something you learned here.

    Lesson list (1)

    • 01
      Python in cwkPippa — A Walking Tour~25 min · epilogue, cwkpippa, tour, self-reference