CPython A Complete Guide to CPython’s Architecture and Performance (Chien-Lung Kao)（Z-Library）

【One-Line Pitch】 A hands-on tour of CPython's C internals that takes you from cloning and compiling the interpreter to reading the structs, bytecode, and object machinery behind everyday Python. Best for experienced Python developers who want to stop treating the interpreter as a black box. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the project — cloning CPython 3.12.6, mapping the source tree, building it, and making a first small modification to the REPL so you see your own change appear in the interpreter. - **Early (~10%–30%)**: Builds the object model from the ground up: PyObject and PyTypeObject, reference counting and immortal objects, the tp_new/tp_init instantiation path, and how lists, strings, and custom built-in types (the PyKitty_Type example) are wired in C. - **Early–Middle (~30%–40%)**: Traces the import system and numeric internals — what really happens during a module import (including circular-import side effects and meta_path), plus how integers and floats are represented and computed. - **Middle (~40%–55%)**: Goes deep on strings and startup — Unicode kind-based storage, interning states, memcpy fast paths, and the generated immortal/static string tables that exist before your code runs. - **Late (~55%–100%)**: Moves to execution machinery — bytecode generation, the virtual machine loop, exception handling, and the advanced object protocols (generators, iterators, descriptors, metaclasses) that tie performance behavior back to design. 【Key Takeaways】 - **"Everything is an object" is literal, not a slogan** (Early): PyObject is the common header every value shares, and PyTypeObject is the table of C function pointers that gives each object its behavior. This is the mental model the rest of the book builds on. - **Reference counting is the primary lifecycle mechanism** (Early): Increment/decrement paths, deallocation via tp_dealloc, and the "immortal object" optimization where refcount operations become no-ops for certain objects. - **Instantiation is a two-step C protocol** (Early): Calling a class routes through tp_call, which invokes tp_new to allocate and tp_init to initialize — the C counterparts of __new__ and __init__. - **Built-in types are just structs full of slots** (Early): List behavior (repr, append, concatenation, sequence protocol) is defined by filling in tp_* and tp_as_sequence fields; unimplemented slots are zeroed out. - **You can add your own built-in type** (Early): The PyKitty_Type walkthrough registers a new type via SETBUILTIN, implements init/repr/dealloc/backflip methods, and makes it importable as a builtin. - **Imports are more dynamic than they look** (Early–Middle): Module loading can trigger re-entrant imports and surprising side effects, with sys.meta_path and path hooks doing the behind-the-scenes discovery work. - **Strings are encoding-aware and heavily optimized** (Middle): Unicode objects track a "kind" (1/2/4-byte) so same-kind copies become raw memcpy, and interning states (not interned, mortal, immortal, static) determine lifetime. - **Numbers and startup are concrete case studies** (Early–Middle): Integers store digits with a compact tag, floats are C doubles with infinity semantics, and startup generates immortal/static strings compiled directly into the interpreter. 【Reading Tips】 - **Deep-read the object-model chapters** (PyObject, PyTypeObject, refcounting, tp_new/tp_init). Everything later assumes this vocabulary; skimming here will make the VM chapters opaque. - **Keep a CPython 3.12.6 checkout open beside the book.** The excerpts repeatedly reference specific files (Include/object.h, Objects/listobject.c, Python/import.c, Modules/main.c). Reading the real source alongside the prose is where the value lands. - **Skim the numeric chapters if you already know IEEE-754.** The integer/float material is a useful refresher but less load-bearing than the object and execution chapters. - **Treat the PyKitty_Type and REPL-modification exercises as must-do, not optional.** They convert passive reading into muscle memory for the C API and build system. - **Note version sensitivity.** The author works against 3.12.6; struct layouts and file paths shift across releases, so verify against your own interpreter version. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book (project setup through strings and startup), so the later execution chapters — bytecode, the VM loop, exceptions, generators, descriptors, and metaclasses — are described from the book's stated scope rather than excerpt detail. Specific chapter titles beyond those visible in the excerpts are not asserted.