Further Reading: OOP Design: Patterns and Principles

Design Principles

Martin, R. C. (2018). Clean Architecture: A Craftsman's Guide to Software Structure and Design. Prentice Hall. (Tier 1) Robert "Uncle Bob" Martin's definitive treatment of SOLID principles and software architecture. Chapters 7-11 cover the SOLID principles in detail with excellent examples. More accessible than his earlier Agile Software Development, though both are valuable.
Sandi Metz. (2018). Practical Object-Oriented Design: An Agile Primer Using Ruby, 2nd Edition. Addison-Wesley. (Tier 1) Don't let "Ruby" in the title scare you — this is one of the clearest books on OOP design ever written. Metz explains coupling, cohesion, and dependency management with a clarity that transcends any single language. The chapter on managing dependencies is worth the entire book.

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. (Tier 1) The original "Gang of Four" (GoF) book that cataloged 23 design patterns. Dense and formal, but still the definitive reference. You don't need to read it cover-to-cover — use it as a reference when you encounter a pattern name. Examples are in C++ and Smalltalk, but the concepts are universal.
Bader, D. (2017). Python Tricks: A Buffet of Awesome Python Features. Dan Bader. (Tier 1) Chapter 4 covers classes and OOP in Python specifically, including Pythonic approaches to patterns. Shows how Python's dynamic nature makes some GoF patterns simpler (or unnecessary) compared to Java/C++.
Refactoring Guru — Design Patterns (https://refactoring.guru/design-patterns) (Tier 1) An outstanding free online resource with visual explanations, pseudocode, and implementations in multiple languages (including Python) for all 23 GoF patterns. The visualizations are particularly helpful for understanding pattern structure.

Fowler, M. (2019). Refactoring: Improving the Design of Existing Code, 2nd Edition. Addison-Wesley. (Tier 1) The definitive guide to refactoring. The second edition uses JavaScript examples (the first used Java), but the catalog of refactoring techniques is language-agnostic. Chapters 3 ("Bad Smells in Code") and 6-12 (the refactoring catalog) are essential reading for any serious programmer.
Fowler, M. "Code Smell" catalog (https://refactoring.guru/refactoring/smells) (Tier 1) A free companion to the book, cataloging common code smells with descriptions, examples, and recommended refactorings. Bookmark this for reference.

Python Documentation: dataclasses module (https://docs.python.org/3/library/dataclasses.html) (Tier 1) The official documentation covers all parameters and options for @dataclass, field(), and related functions. The "Immutable instances" and "Ordering" sections are particularly useful.
Hettinger, R. "Dataclasses: The code generator to end all code generators" (PyCon 2018 talk, available on YouTube). (Tier 1) Raymond Hettinger (one of Python's core developers) explains the design decisions behind dataclasses and demonstrates advanced usage. Entertaining and informative — Hettinger is one of the best Python presenters.

Norvig, P. "Design Patterns in Dynamic Languages" (1998 talk). (Tier 2) Peter Norvig (Director of Research at Google) demonstrates that 16 of the 23 GoF patterns are either invisible or greatly simplified in dynamic languages like Python. A useful counterbalance to pattern enthusiasm.
Hickey, R. "Simple Made Easy" (Strange Loop 2011 talk, available on InfoQ). (Tier 2) Rich Hickey (creator of Clojure) makes a compelling case for simplicity over complexity in software design, including a thoughtful critique of unnecessary OOP. Challenges you to think about whether your classes are adding clarity or just adding structure.

Hunt, A. & Thomas, D. (2019). The Pragmatic Programmer, 20th Anniversary Edition. Addison-Wesley. (Tier 1) A classic book on software craftsmanship that covers design principles, coupling, and the "Don't Repeat Yourself" (DRY) principle. Practical, opinionated, and highly readable. If you read one book on being a better programmer, make it this one.
Percival, H. & Gregory, B. (2020). Architecture Patterns with Python. O'Reilly. (Tier 2) Goes beyond what this chapter covers into domain-driven design, the Repository pattern, and event-driven architecture — all in Python. A natural next step after mastering the patterns in this chapter.