High Performance Python, 3rd Edition Practical Performant Programming for Humans (Micha Gorelick, Ian Ozsvald)（Z-Library）

【One-Line Pitch】 A practical field guide to making Python code run faster, from profiling bottlenecks to compiling, parallelizing, and scaling beyond a single machine. Best for experienced Python programmers who already write working code and now need it to handle high data volumes, multicore hardware, and GPUs. 【Book Arc】 - **Opening (~0%–10%)**: Frames the core problem—correct code that is too slow—and introduces the machine model underneath Python: CPU, memory hierarchy, buses, and why data movement, not just computation, dominates performance. - **Early (~10%–35%)**: Teaches profiling as the entry point to optimization, using CPU and memory profilers (cProfile, line profilers, Scalene, Specialist) to find real bottlenecks instead of guessing, with the Julia set as a running example. - **Middle (~35%–55%)**: Builds data-structure intuition—lists, tuples, dictionaries, and sets—explaining their complexity guarantees, resizing behavior, and when each answers your data questions fastest. - **Late (~55%–85%)**: Moves into acceleration and scale: NumPy and vectorized computation, compilation tools like Cython, DataFrame processing with Pandas, Dask, and Polars, GPU and neural-network speedups, and concurrency for I/O and computation. - **Ending (~85%–100%)**: Closes with distributed execution—converting multiprocessing code to local or remote clusters—plus "Lessons from the Field" war stories from companies applying high-performance Python in production. 【Key Takeaways】 - **Profile before you optimize** (Early): The book's central discipline is stating a testable hypothesis, changing one thing at a time, and gathering evidence—never optimizing on intuition alone. - **Performance is often about memory movement, not raw computation** (Opening): Understanding caches, buses, and data layout explains why some "fast" code stalls and why GPU transfers can be costly. - **Data structure choice is a performance decision** (Middle): Lists and tuples give O(1) positional access; dictionaries and sets trade memory for near-constant lookups, with resizing behavior you should understand. - **The GIL shapes Python's concurrency story** (Early): Multithreaded code can run at single-thread speed, which is why multiprocessing and other standard solutions matter—and why PEP 703's GIL-free future is significant. - **Compilation and vectorization unlock large gains** (Late): NumPy, Cython, and JIT developments let you push hot loops closer to machine speed when pure Python plateaus. - **DataFrame tooling has diversified** (Late): Pandas, Dask, and Polars offer different trade-offs for processing large tabular data quickly. - **Scaling out is a distinct skill from speeding up** (Ending): The book treats moving multiprocessing code to clusters as its own practical challenge, not an afterthought. - **Real-world lessons complement theory** (Ending): Field stories from GenAI data extraction and productionized machine learning ground the techniques in actual constraints. 【Reading Tips】 - Deep-read the profiling chapters early; they set up every later optimization and prevent wasted effort. - Skim the hardware/bus material on a first pass, then return to it when a specific bottleneck puzzles you. - Treat the data-structure chapters as reference—revisit them when choosing containers in your own code. - For the acceleration chapters, pick the tool matching your workload (NumPy/Cython for CPU loops, Dask/Polars for DataFrames, GPU tooling for neural networks) rather than reading linearly. - Read "Lessons from the Field" last, as a reality check on the trade-offs the technical chapters describe. 【Coverage Limits】 The excerpts cover the book's framing, profiling, data structures, and high-level roadmap, but do not detail the specific APIs, benchmarks, or code in the compilation, GPU, and distributed chapters. Chapter-level specifics beyond those shown are not covered here.