Python 3 面向对象编程（第2版） (Dusty Phillips)（Z-Library）

【One-Line Pitch】 A practical, example-driven guide to writing idiomatic object-oriented Python 3, from core design principles through built-in shortcuts and design patterns to concurrency. Best for developers who already know some Python but want to think seriously about classes, inheritance, and when OOP actually pays off. 【Book Arc】 - **Opening (~0%–15%)**: Frames OOP as a design discipline, not just syntax—covering analysis, design, and programming as related stages, plus naming, abstraction, and modeling only what the system needs. - **Early (~15%–35%)**: Builds the mechanics of reuse and robustness: inheritance, extending built-ins, `super()`, multiple inheritance and the diamond problem, polymorphism/duck typing, and exception handling with custom exceptions. - **Middle (~35%–55%)**: Shifts from "how" to "when"—deciding when a class is warranted, properties and attribute behavior, manager objects, and Python's built-in data structures (sets, queues, named tuples, ordered dicts). - **Late (~55%–80%)**: Explores Python's "shortcuts" that abstract over OOP—built-in functions, file I/O and context managers, method-overloading alternatives, and functions-as-objects—then moves into common design patterns implemented the Pythonic way. - **Ending (~80%–100%)**: Introduces concurrency in Python 3, which the author admits is not strictly OOP but is essential context for the ecosystem; readers may skip it if uninterested. 【Key Takeaways】 - **OOP is a design mindset before it is syntax** (Opening): analysis asks *what* is needed, design asks *how*, and coding realizes it—so naming and abstraction choices matter more than class keywords. - **Model only what the current task requires** (Opening): avoid speculative objects and behaviors; keep interfaces minimal and open to future change rather than pre-building for imagined needs. - **Inheritance is powerful but easy to misuse** (Early): multiple inheritance and the diamond problem show why `super()` and method resolution order deserve careful attention, and why composition is often safer. - **Duck typing loosens polymorphism's grip on class hierarchies** (Early): any object providing the needed behavior can participate, so Python rewards interface thinking over strict subclassing. - **Exceptions are control flow, not just errors** (Early): `try/except/else/finally` ordering, custom exception classes, and cleanup semantics shape robust object designs. - **Properties blur the line between data and behavior** (Middle): computed attributes, validation, and proxying let you expose clean interfaces while keeping logic encapsulated. - **Python's built-ins and data structures are OOP shortcuts** (Middle/Late): sets, queues, named tuples, context managers, and built-in functions map onto underlying object implementations you can leverage. - **Design patterns should be adapted, not transplanted** (Late): the book favors idiomatic Python implementations over rigid classical pattern structures. 【Reading Tips】 - Deep-read the early chapters on inheritance, `super()`, and exceptions—these are the conceptual load-bearing walls; skim if you already know them well. - Treat each chapter's case study as the real payoff: it stitches the chapter's ideas into a working example, so read it actively rather than skipping to exercises. - Do the end-of-chapter exercises against your own past projects; the author explicitly intends them to retrofit OOP onto real code, not toy problems. - The concurrency chapters can be read independently—if you're focused purely on OOP, note them and return later. - Keep a scratchpad for class diagrams while reading; the book encourages sketching relationships to internalize design thinking. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the book's structure, early design chapters, inheritance, exceptions, and portions of the data-structure and shortcut chapters. The design-pattern and concurrency chapters are referenced by the book's own outline but their detailed content is not covered in the excerpts.