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

   Python's most love-it-or-hate-it feature. Three lessons: the basics (function wrapping, @ syntax, functools.wraps and why metadata matters), decorator factories (decorators that take arguments) plus class-as-decorator (__call__) plus the built-ins (@property, @staticmethod, @classmethod, @dataclass, @cached_property, @lru_cache), and real-world patterns (timing, logging, retry, auth).

   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. Multiple inheritance and how Python resolves it (MRO, C3 linearization, super() cooperative inheritance), Mixin pattern vs Composition over Inheritance, the *workarounds* for function overloading Python doesn't have (singledispatch, typing.overload, multimethod), metaclass — yes, classes are objects too — and descriptors, which are how @property and @classmethod actually work under the hood. Plus __slots__, __init_subclass__, weakref, and a peek at memory management and the GC.

   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 / pickle / mmap / streaming

   Reading and writing data without losing your mind. Text vs binary mode, encoding (yes, utf-8 by default in 3.x — but you'll meet legacy systems), pathlib over os.path (modern Python prefers it), JSON and CSV the standard library way, pickle and its security caveat, tempfile for scratch work, mmap for files that don't fit in memory, streaming patterns for large files.

   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 by Default and the 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 / itertools / functools / datetime / re / logging

    The phrase 'Python comes with batteries included' refers to *this*. collections (deque, Counter, defaultdict, OrderedDict, namedtuple), itertools (chain, groupby, product, accumulate), functools (cache, partial, reduce, wraps, singledispatch), pathlib (modern path manipulation), datetime + zoneinfo (3.9+ — finally proper timezones), re (regex deep enough to be useful), logging (because print() doesn't scale), subprocess + shutil for shelling out. You'll never reach for a third-party library again where stdlib already has it.

    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 / 3.12 type

    Python's type system, optional but powerful. Basic annotations (int, str, list[int], dict[str, int]), TypedDict for structured dicts, Literal / Final / ClassVar for precise constraints, generics with TypeVar / Generic / ParamSpec / typing.Self, Pydantic for runtime-validated types (the cwkPippa stack uses this everywhere), the new `type` keyword (3.12+), and the difference between mypy / pyright / ty when it comes to actually checking your code.

    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

    Python has three concurrency models, and choosing the wrong one is the most common production mistake. asyncio + async/await (cwkPippa's main pattern), threading (and the GIL — and the 3.13 free-threaded experimental mode), multiprocessing (real parallel CPU work), concurrent.futures (the unifying high-level API), shared memory and queues, and the decision framework for *when to use which* — because async is not always the answer.

    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

    Code that works on your laptop and code that works in production are not the same code. pytest (fixtures, parametrize, marks), mock and unittest.mock for boundaries, pdb and breakpoint() for actual debugging, cProfile + timeit + memory profiling for *measuring* before optimizing, ruff (the new fast linter/formatter), mypy / pyright for type checking, pre-commit for keeping the repo honest, coverage for knowing what your tests actually cover, and hypothesis for property-based testing.

    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 / where every Pythonic Way callout converges

    The track every other track has been pointing to. EAFP vs LBYL, duck typing and structural subtyping, the comprehension idiom over map/filter, when to reach for a generator, when *not* to use a class, the dunder methods that integrate your objects into the language, and a tour of patterns that *look* fine but aren't Pythonic — code that passes review and still gets refactored. Each lesson in this quest has a 'Pythonic Way' callout; this track is where they all come together.

    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