Python Cookbook（第3版）中文版 (大卫·比斯利（David Beazley） etc.) (Z-Library)

【One-Line Pitch】 A practical, recipe-based reference for intermediate Python programmers, this book solves real-world problems across data structures, text processing, I/O, classes, metaprogramming, and more, with deep explanations of how and why each solution works. If you write Python for a living and want battle-tested patterns to apply directly to your projects, this is your desk-side companion. 【Book Arc】 - **Opening (~0%–10%)**: The book opens with a broad overview of its scope—from data structures and algorithms to C extensions—and immediately dives into foundational recipes. Early chapters cover core data handling: using `namedtuple` to decouple code from positional data, and mastering regular expressions for text matching and capture groups. - **Early (~10%–29%)**: This stage focuses on text cleaning, filtering, and encoding (e.g., `strip()`, `translate()`, `html.escape()`), then moves into numeric and scientific computing with NumPy for linear algebra. It also introduces iterators and generators, including manual iteration with `next()`, slicing iterables with `islice()`, and flattening nested sequences with `yield from`. - **Middle (~29%–48%)**: The book shifts to file I/O (using `StringIO`/`BytesIO` for in-memory files) and data encoding, with a deep dive into parsing XML with `ElementTree` and handling namespaces. A highlight is a complex, advanced example of building a binary data parser using descriptors and metaprogramming. This section also covers functions (closures, arbitrary arguments) and classes, including `property` for computed attributes and descriptors as the "magic" behind `@classmethod` and `@staticmethod`. - **Late (~48%–end)**: The final stretch covers advanced class patterns like state machines (avoiding messy condition checks), the visitor pattern for tree traversal (with a non-recursive generator-based variant), and using `@total_ordering` to simplify comparison operators. The book concludes with practical topics like testing, debugging, and C extensions, as outlined in the introduction. 【Key Takeaways】 - **Named tuples decouple code from data structure** (Early): Converting positional tuples to `namedtuple` instances (e.g., `Stock(name, shares, price)`) makes code more readable and resilient to schema changes, like adding a new column to a database result. - **Precompile regex patterns for repeated matching** (Early): Using `re.compile()` and methods like `match()` and `findall()` improves performance and clarity; capture groups `(\d+)` let you extract matched parts individually. - **Generators are memory-efficient data transformers** (Early): Expressions like `(line.strip() for line in f)` process data lazily without creating temporary lists, ideal for cleaning text lines from large files. - **`yield from` simplifies recursive generators** (Early): Flattening nested iterables becomes elegant with `yield from flatten(x)`, and you can exclude strings/bytes from being treated as iterables to avoid unwanted character-level splitting. - **Descriptors are the foundation of Python's class magic** (Middle): Implementing `__get__`, `__set__`, and `__delete__` lets you customize attribute access, powering features like `@property` and type-checking systems; remember they must be class-level, not instance-level, attributes. - **Use `property` for computed attributes without breaking interfaces** (Middle): Defining `area` and `perimeter` as properties on a `Circle` class keeps the API uniform (no parentheses), and you can upgrade plain attributes to properties later without changing client code. - **Replace complex state checks with dedicated classes** (Late): A connection class with many `if self.state == ...` checks becomes simpler and faster by modeling each state as a separate class, improving both readability and performance. - **Non-recursive visitor patterns prevent stack overflow** (Late): Using a stack and generators instead of recursion lets you traverse deeply nested trees without hitting Python's recursion limit, while preserving the visitor pattern's structure. 【Reading Tips】 - **Skim the "Problem" and "Solution" headers first**: Each recipe is self-contained; if you recognize the problem, jump straight to the code and the "Discussion" section for the "why." - **Deep-read the advanced binary parsing example (Chapter 6)**: This is flagged as one of the book's most advanced sections, combining OOP, descriptors, and metaprogramming. Read it slowly and cross-reference earlier chapters on classes and functions. - **Treat the book as a reference, not a cover-to-cover read**: Use the table of contents to find specific problems (e.g., "reading CSV," "parsing XML"). The recipes are designed for quick lookup and direct application. - **Pay attention to the "Discussion" sections**: They explain trade-offs, performance implications, and alternative approaches—this is where the real learning happens beyond the copy-paste solution. - **Note the Python 3.3 context**: Code was tested on Python 3.3; some APIs (e.g., `collections.Iterable`) may have moved (e.g., to `collections.abc`), so be ready to adapt for modern Python versions. 【Coverage Limits】 This guide synthesizes the book's core themes from the sampled excerpts (roughly the first half). It does not cover later chapters on modules/packages, networking, concurrency, testing, or C extensions in detail, as those sections were not included in the source material.