Python learning tracks

See how the site grades each exercise, with its tests and with mypy in strict mode. Fix your first type errors, learn what strict mode checks, and use the optional placement tests to find where to start.

Check a value's type before you use it, limit what a value can be with Literal, Final and NewType, and write reusable functions and classes with generics. Learn why mypy will not pass a list[int] where a list[object] is expected, and finish by modernizing a typed module.

Describe what a function needs from its arguments with protocols and abstract base classes. Then give precise types to dictionaries, overloads and decorators, and find where Any and missing stubs leave code unchecked.

Write classes that hold data with dataclasses, and control their defaults, equality, hashing and memory use. Choose between a dataclass, NamedTuple and TypedDict, and turn outside data into typed records your code can trust.

Format text with f-strings and your own format codes, branch on the shape of data with match and case, and use := and keyword-only parameters where they make code clearer. The track ends with the syntax new in Python 3.14 and 3.15.

Count, group and queue data with collections and heapq, stream it with generators and itertools, and cache results with functools. Clean up with contextlib, and handle paths, enums, TOML config and time zones.

Read a traceback, catch errors by category, and design exceptions your callers can act on. Keep the original error when you wrap it, report several failures at once, retry failed calls, and warn callers before you remove a function.

Chain generators into pipelines that read one item at a time, so you can process data too big to hold in memory. Learn when each step runs, how to type iterables and iterators, and how to batch and join streams.

Write tests that fail when the code breaks. Share setup with fixtures, swap slow dependencies for fakes, run one test over many cases, and let Hypothesis find the inputs you missed.

Run several tasks at once. Start with thread pools and locks, move on to asyncio for programs that wait on many network calls, and finish with timeouts, cancellation and clean shutdown.

Spread CPU-heavy work across cores with a process pool. Learn what you can send to a worker and how workers start. Share large data safely, and debug workers that hang or crash.

See when two names share one object, what keeps an object alive, and how to measure memory. Then time and profile slow code before you change it. The track ends with optional reading on the garbage collector, profilers, the JIT and native extensions.

See how Python finds your modules, fix circular imports, and pass dependencies in so you can test each part on its own. Then build and install a wheel, lock your dependencies, and set up Ruff, mypy and CI.

Check outside data once, where it enters your program, and turn config files, environment variables and request bodies into typed values. Decode bytes on purpose, run commands without a shell, keep user input out of SQL, and log from a library so each application controls what it sees.

Five larger exercises that each combine several earlier tracks. Give each state of an upload its own type, check a package's import rules, build an immutable order model from untrusted data, extend the worker pool to keep going after failures, and fix five performance problems in an order pipeline.