Python for Staff Engineers

The parts

1. Part I · Python Foundations The ground floor, built right, objects, names, numbers & text, the model everything else rests on, with the staff-grade gotchas (identity, IEEE-754, mutable defaults, LEGB) called out from the start.
2. Part II · Data Structures & Pythonic Idioms The built-in containers in depth, dict, set, the collections toolkit, plus comprehensions, pattern matching, and the idioms that mark code as written by someone who knows Python.
3. Part III · Functions, Closures & Functional Python Functions as values, closures, decorators, generators & the itertools toolbox, the functional core that makes Python expressive, and the lazy pipelines that make it scale.
4. Part IV · Objects & OOP Classes done properly, the MRO, super() , descriptors-via-properties, ABCs, plus dataclasses and the judgement to know when a class is the wrong tool entirely.
5. Part V · The Data Model & Protocols The dunder protocols that wire your objects into the language, operators, containers, iteration, descriptors, context managers, so your types feel native. This is the heart of Python.
6. Part VI · Metaprogramming Code that writes code. Classes are objects, type is their maker, and the import system, inspect , and ast let you read and rewrite programs at runtime, power to wield sparingly .
7. Part VII · Typing & Static Analysis at Depth Gradual typing as a design tool, generics, variance, protocols, narrowing, and the checkers (mypy · pyright · ty) that turn annotations into a safety net without changing what runs.
8. Part VIII · CPython Internals I The Interpreter How CPython turns your source into running bytecode, tokenizer → PEG → AST → compiler → code object → ceval, and the object substrate, refcounts, specializing interpreter, and JIT underneath.
9. Part IX · CPython Internals II Memory & Garbage Collection How objects are allocated and reclaimed, pymalloc arenas, refcounts, the cyclic generational GC, plus weakrefs, __slots__ , zero-copy buffers, and finding leaks with tracemalloc .
10. Part X · Concurrency I Threads, the GIL & Free Threading The Global Interpreter Lock, what it protects, what it costs, threads, locks, queues, pools, when threading actually helps, and the no-GIL future (PEP 703) reshaping it all.
11. Part XI · Concurrency II Asyncio & Async Python Cooperative multitasking on one thread, coroutines, the event loop, tasks, structured concurrency, scaling to thousands of concurrent I/O operations without a thread each.
12. Part XII · Multiprocessing & Parallelism Real multi-core CPU parallelism by sidestepping the GIL with separate processes, start methods, pools, IPC, shared memory, and the serialization cost that comes with isolation.
13. Part XIII · Performance Engineering Make it fast after you make it work, measure, profile, find the hotspot, optimize the algorithm, because intuition about where Python spends time is almost always wrong.
14. Part XIV · Beyond CPython Native Code & Acceleration When pure Python is the floor, drop to C, Cython, Rust, or a different runtime, C-API, ctypes, Numba, PyO3, PyPy, and ship the compiled result as a wheel.
15. Part XV · The Standard Library & Robust Code Batteries included, the stdlib modules that handle files, text, time, processes, logging, and data, plus the error-handling architecture that makes code robust.
16. Part XVI · Packaging, Tooling & Environments How Python code becomes a shippable, reproducible artifact in 2026, uv, ruff, ty, pyproject.toml, wheels & CI, the toolchain that turns a folder of .py files into a package others can trust.
17. Part XVII · Testing, Quality & Correctness Proving the code actually works, and keeps working, unittest, pytest, mock, Hypothesis, coverage & CI, the discipline that turns "it ran once" into "it is correct, and a regression fails the build."
18. Part XVIII · Design, Architecture & Patterns Structuring code that survives change, SOLID, composition, hexagonal architecture & the patterns Python makes trivial, where the staff engineer earns their title: choosing structure, recording the tradeoff, and keeping coupling low as the system grows.
19. Part XIX · Python in Production Web, Data & Services Where Python actually lives, serving traffic and crunching data, WSGI/ASGI, FastAPI, SQLAlchemy, observability & the data stack, the architecture, the bottlenecks, and the operational reality of running Python under load.
20. Part XX · Security, Reliability & the Staff Dimension Hardening what you ship, and the leadership that ships it, defensive security, supply chain, reliability patterns & the staff engineer's path, the dimension where correctness meets consequences and influence outweighs code.
21. Part XXI · Capstone & Reference One real service that exercises the whole book, typed, tested, packaged, observable, then the master cheat sheets, the canon, and the path forward. Where every Part comes together in shippable code.