Python in a Nutshell, 4th Edition (Alex Martelli, Anna Martelli Ravenscroft etc.)（Z-Library）

【One-Line Pitch】 A dense, authoritative desktop reference for programmers who already know how to code and want Python 3.10's rules, idioms, and standard-library machinery explained precisely. Best for working developers who need a fast, reliable answer rather than a beginner's tutorial. 【Book Arc】 - **Opening (~0%–10%)**: Orients you to the book's scope and to Python's ecosystem — installation, interpreters, virtual environments, and version-management tools like conda and pyenv — solving the "which Python am I even running?" problem before any language detail. - **Early (~10%–32%)**: Lays the language foundation: lexical structure, lines and indentation, string literals and escape sequences, operators (including short-circuiting and the conditional expression), sets and their mutating methods, and the full function toolkit — positional/named parameters, closures with `nonlocal`, and `lambda`. - **Early–Middle (~23%–42%)**: Moves into modern control flow and object orientation: structural pattern matching with guards and `__match_args__`, then classes, inheritance, `super`, dynamic class creation via `type(name, bases, attrs)`, and attribute-access internals like `__getattribute__` and `__hash__`. - **Middle (~42%–48%)**: Deepens OOP with decorators (including `functools.wraps`), metaclasses, and typing machinery — `@typing.overload` for static checking versus `functools.singledispatch` for runtime dispatch, plus `cast`. - **Late (~48% onward)**: The library and extension-module half: regular expressions, file and text operations with internationalization, persistence and databases (including bundled SQLite), time operations, execution customization, concurrency via threads and processes, numeric processing, and testing/debugging/optimizing. - **Ending**: Closes on correctness and performance — warnings, debugging approaches, and optimization — the practical payoff for everything covered earlier. 【Key Takeaways】 - **This is a reference, not a course** (Opening): the authors state plainly they are not teaching Python and move at a fast pace, focusing on rules first and best practices second — so it rewards readers who already know another language. (Early) - **Layout is part of Python's grammar** (Early): indentation, logical versus physical lines, and comment rules are treated as core lexical structure, with an explicit warning for readers arriving from other languages. - **Modern Python means pattern matching** (Early): `match`/`case` with guards, plus `__match_args__` to let your own classes participate in positional patterns, is presented as a first-class language feature. - **Functions carry real depth** (Early): positional and named parameters, default-value evaluation at `def` time, `global` versus `nonlocal`, closures, and `lambda` are covered as a connected system rather than isolated syntax. - **OOP internals are fair game** (Middle): `super` discipline, dynamic class creation with `type`, and the cost of overriding `__getattribute__` show how much control — and how much performance risk — the object model exposes. - **Static typing and runtime dispatch are different tools** (Middle): `@typing.overload` exists purely for type checkers, while `functools.singledispatch` handles actual runtime behavior — a distinction the book makes explicit. - **The standard library is the second half of the book** (Late): regex, file/text I/O, persistence and SQL databases, time, concurrency, and numerics are treated as core Python competence, not optional extras. - **Correctness and speed close the loop** (Ending): testing, debugging, warnings, and optimization are framed as the discipline that makes everything earlier trustworthy. 【Reading Tips】 - **Skim the opening setup chapters** if your environment is already sorted; the real value starts with the language chapters. - **Deep-read the function, class, and typing sections** — these are where the book's precision pays off most, especially the `overload` versus `singledispatch` contrast. - **Treat the library chapters as lookup material**: read the concurrency and persistence chapters once for orientation, then return when you have a concrete task. - **Watch the version markers**: the book targets 3.10 with previews of 3.11, so note which features are new before assuming they exist in your runtime. - **Keep PEP 8 nearby** — the authors explicitly defer style guidance to it rather than duplicating it. 【Coverage Limits】 The excerpts cover the book's structure, language fundamentals, OOP, and a chapter-level map of the library sections, but do not include detailed content from the regex, database, concurrency, or testing chapters. Specific examples and figures from those later chapters are not represented here.