[PDF] Robust Python: Write Clean and Maintainable Code Free Download


Does it seem like your Python projects are getting bigger and bigger? Are you feeling the pain as your codebase expands and gets tougher to debug and maintain? Python is an easy language to learn and use, but that also means systems can quickly grow beyond comprehension. Thankfully, Python has features to help developers overcome maintainability woes.

In this practical book, author Patrick Viafore shows you how to use Python’s type system to the max. You’ll look at user-defined types, such as classes and enums, and Python’s type hinting system. You’ll also learn how to make Python extensible and how to use a comprehensive testing strategy as a safety net. With these tips and techniques, you’ll write clearer and more maintainable code.

  • Learn why types are essential in modern development ecosystems
  • Understand how type choices such as classes, dictionaries, and enums reflect specific intents
  • Make Python extensible for the future without adding bloat
  • Use popular Python tools to increase the safety and robustness of your codebase
  • Evaluate current code to detect common maintainability gotchas
  • Build a safety net around your codebase with linters and tests


About This Book

Python is a wonderful language, but it occasionally makes building for the future tricky. Some proponents of other programming languages have decried Python as “not production-grade” or “useful for prototyping only,” but the truth is that many developers only scratch the surface, rather than learning all the tools and tricks for writing robust Python. Throughout this book, you’ll learn how to do better. You’ll journey through numerous ways to make Python clean and maintainable. Your future maintainers will enjoy working with your code, as it was designed up front to make things easy. So go, read this book, look toward the future, and build awesome software that will last.

Ideal readers include:

Developers currently working in a large codebase, looking to find better ways to communicate with their colleagues

Primary codebase maintainers, looking for ways to help lessen the burden of future maintainers

Self-taught developers who can write Python really well but need to better understand why we do the things we do

Software engineering graduates who need a reminder of practical advice for development

Senior developers looking for a way to tie their design rationale to first principles of robustness

Who Should Read This Book

This book is for any Python developer who is looking to grow the code they work on in a sustainable and maintainable fashion. This is not intended to be your first Python text; I expect that you have written Python before. You should be comfortable with Python control flow, and have worked with classes before. If you are looking for a more introductory text, I suggest reading Learning Python by Mark Lutz (O’Reilly) first.

While I will be covering many advanced Python topics, the goal of this book is not to be a how-to for using all of Python’s features. Instead, the features are a backdrop for a larger conversation about robustness and how your choices impact maintainability. At times I will discuss strategies that you should rarely use, if at all. That is because I want to illustrate first principles of robustness; the journey of understanding why and how we make decisions in code is more important than knowing what tools to use in an optimal scenario. In practice, the optimal scenario is a rare occurence. Use the principles in this book to draw your own conclusions from your codebase.

This book is not a reference book. You might call it a discussion book. Each chapter should be a starting point for developers in your organization to discuss, together, how best to apply these principles. Start a book club, discussion group, or lunch and learn to foster communication. I have proposed discussion topics in each chapter to get the converstation started. When you come across these topics, I encourage you to stop and reflect on your current codebase. Talk among your peers and use these topics as a springboard for discussing the state of your code, processes, and workflows. If you are interested in a reference book about the Python language, I heartily recommend Fluent Python by Luciano Ramalho (O’Reilly; a second edition is forthcoming in late 2021).

A system can be robust in many different ways. It can be security hardened, scalable, fault-tolerant, or less likely to introduce new errors. Each one of these facets of robustness warrants a full book; this book is focused on preventing the developers who inherit your code from creating new faults in your system. I will show you how to communicate to future developers, how to make their lives easier through architectural patterns, and how to catch errors in your codebase before they make it into production. This book zeroes in on the robustness of your Python codebase, not the robustness of your system as a whole.

I will be covering a wealth of information, from many different areas of software, including software engineering, computer science, testing, functional programming, and object-oriented programming (OOP). I do not expect you to have a background in these fields. There are sections where I explain things at a beginner level; this is often to deconstruct how we think about core fundamentals of the language. This is, for the most part, an intermediate-level text.

This book focuses on writing software over time. If a lot of your code is a prototype, throwaway, or disposable in any other fashion, the advice in this book will end up creating more work than is necessary for your project. Likewise if your project is small—say, under one hundred lines of Python. Making code maintainable does add complexity; there’s no doubt about that. However, I’ll guide you through minimizing that complexity. If your code lives longer than a few weeks or grows to a considerable size, you need to consider the sustainability of your codebase.


O’Reilly’s mission is to change the world by sharing the knowledge of innovators. For over 40 years, we’ve inspired companies and individuals to do new things (and do them better) by providing the skills and understanding that are necessary for success.

At the heart of our business is a unique network of expert pioneers and practitioners who share their knowledge through the O’Reilly learning platform and our books—which have been heralded for decades as the definitive way to learn the technologies that are shaping the future. So individuals, teams, and organizations learn the tools, best practices, and emerging trends that will transform their industries.

Our customers are hungry to build the innovations that propel the world forward. And we help them do just that.

Table of contents :

Table of Contents
Who Should Read This Book
About This Book
Conventions Used in This Book
Using Code Examples
O’Reilly Online Learning
How to Contact Us
Chapter 1. Introduction to Robust Python
Why Does Robustness Matter?
What’s Your Intent?
Asynchronous Communication
Examples of Intent in Python
Law of Least Surprise
Closing Thoughts
Part I. Annotating Your Code with Types
Chapter 2. Introduction to Python Types
What’s in a Type?
Mechanical Representation
Semantic Representation
Typing Systems
Strong Versus Weak
Dynamic Versus Static
Duck Typing
Closing Thoughts
Chapter 3. Type Annotations
What Are Type Annotations?
Benefits of Type Annotations
Exercise: Spot the Bug
When to Use Type Annotations
Closing Thoughts
Chapter 4. Constraining Types
Optional Type
Union Types
Product and Sum Types
Literal Types
Annotated Types
Final Types
Closing Thoughts
Chapter 5. Collection Types
Annotating Collections
Homogeneous Versus Heterogeneous Collections
Creating New Collections
Modifying Existing Types
As Easy as ABC
Closing Thoughts
Chapter 6. Customizing Your Typechecker
Configuring Your Typechecker
Configuring mypy
Mypy Reporting
Speeding Up mypy
Alternative Typecheckers
Closing Thoughts
Chapter 7. Adopting Typechecking Practically
Breaking Even Earlier
Find Your Pain Points
Target Code Strategically
Lean on Your Tooling
Closing Thoughts
Part II. Defining Your Own Types
Chapter 8. User-Defined Types: Enums
User-Defined Types
When Not to Use
Advanced Usage
Automatic Values
Integer Conversion
Closing Thoughts
Chapter 9. User-Defined Types: Data Classes
Data Classes in Action
String Conversion
Relational Comparison
Comparison to Other Types
Data Classes Versus Dictionaries
Data Classes Versus TypedDict
Data Classes Versus namedtuple
Closing Thoughts
Chapter 10. User-Defined Types: Classes
Class Anatomy
Avoiding Broken Invariants
Why Are Invariants Beneficial?
Communicating Invariants
Consuming Your Class
What About Maintainers?
Encapsulation and Maintaining Invariants
Encapsul-what, Now?
Protecting Data Access
Closing Thoughts
Chapter 11. Defining Your Interfaces
Natural Interface Design
Thinking Like a User
Natural Interactions
Natural Interfaces in Action
Magic Methods
Context Managers
Closing Thoughts
Chapter 12. Subtyping
Design Considerations
Closing Thoughts
Chapter 13. Protocols
Tension Between Typing Systems
Leave the Type Blank or Use Any
Use a Union
Use Inheritance
Use Mixins
Defining a Protocol
Advanced Usage
Composite Protocols
Runtime Checkable Protocols
Modules Satisfying Protocols
Closing Thoughts
Chapter 14. Runtime Checking With pydantic
Dynamic Configuration
Validation Versus Parsing
Closing Thoughts
Part III. Extensible Python
Chapter 15. Extensibility
What Is Extensibility?
The Redesign
Open-Closed Principle
Detecting OCP Violations
Closing Thoughts
Chapter 16. Dependencies
Types of Dependencies
Physical Dependencies
Logical Dependencies
Temporal Dependencies
Visualizing Your Dependencies
Visualizing Packages
Visualizing Imports
Visualizing Function Calls
Interpreting Your Dependency Graph
Closing Thoughts
Chapter 17. Composability
Policy Versus Mechanisms
Composing on a Smaller Scale
Composing Functions
Composing Algorithms
Closing Thoughts
Chapter 18. Event-Driven Architecture
How It Works
Simple Events
Using a Message Broker
The Observer Pattern
Streaming Events
Closing Thoughts
Chapter 19. Pluggable Python
The Template Method Pattern
The Strategy Pattern
Plug-in Architectures
Closing Thoughts
Part IV. Building a Safety Net
Chapter 20. Static Analysis
Writing Your Own Pylint Plug-in
Breaking Down the Plug-in
Other Static Analyzers
Complexity Checkers
Security Analysis
Closing Thoughts
Chapter 21. Testing Strategy
Defining Your Test Strategy
What Is a Test?
Reducing Test Cost
AAA Testing
Closing Thoughts
Chapter 22. Acceptance Testing
Behavior-Driven Development
The Gherkin Language
Executable Specifications
Additional behave Features
Parameterized Steps
Table-Driven Requirements
Step Matching
Customizing the Test Life Cycle
Using Tags to Selectively Run Tests
Report Generation
Closing Thoughts
Chapter 23. Property-Based Testing
Property-Based Testing with Hypothesis
The Magic of Hypothesis
Contrast with Traditional Tests
Getting the Most Out of Hypothesis
Hypothesis Strategies
Generating Algorithms
Closing Thoughts
Chapter 24. Mutation Testing
What Is Mutation Testing?
Mutation Testing with mutmut
Fixing Mutants
Mutation Testing Reports
Adopting Mutation Testing
The Fallacy of Coverage (and Other Metrics)
Closing Thoughts
About the Author

Product information

Publisher‏:‎O’Reilly Media; 1st edition (August 3, 2021)
Paperback‏:‎380 pages
Item Weight‏:‎1.33 pounds
Dimensions‏:‎7 x 0.78 x 9.19 inches

Download Robust Python: Write Clean and Maintainable Code Pdf Free:

You can easily download Robust Python: Write Clean and Maintainable Code PDF by clicking the link given below. If the PDF link is not responding, kindly inform us through comment section. We will fixed it soon.

Click Here to download

“ NOTE: We do not own copyrights to these books. We’re sharing this material with our audience ONLY for educational purpose. We highly encourage our visitors to purchase original books from the respected publishers. If someone with copyrights wants us to remove this content, If you feel that we have violated your copyrights, then please contact us immediately. please contact us. or Email: [email protected]

Leave A Reply

Your email address will not be published.

three × one =