Table of Contents
Preface xiii
Acknowledgments xvii
About the Author xix
Chapter 1: Pythonic Thinking 1
Item 1: Know Which Version of Python You’re Using 1
Item 2: Follow the PEP 8 Style Guide 2
Item 3: Know the Differences Between bytes, str, and unicode 5
Item 4: Write Helper Functions Instead of Complex Expressions 8
Item 5: Know How to Slice Sequences 10
Item 6: Avoid Using start, end, and stride in a Single Slice 13
Item 7: Use List Comprehensions Instead of map and filter 15
Item 8: Avoid More Than Two Expressions in List Comprehensions 16
Item 9: Consider Generator Expressions for Large Comprehensions 18
Item 10: Prefer enumerate Over range 20
Item 11: Use zip to Process Iterators in Parallel 21
Item 12: Avoid else Blocks After for and while Loops 23
Item 13: Take Advantage of Each Block in try/except/else/finally 26
Chapter 2: Functions 29
Item 14: Prefer Exceptions to Returning None 29
Item 15: Know How Closures Interact with Variable Scope 31
Item 16: Consider Generators Instead of Returning Lists 36
Item 17: Be Defensive When Iterating Over Arguments 38
Item 18: Reduce Visual Noise with Variable Positional Arguments 43
Item 19: Provide Optional Behavior with Keyword Arguments 45
Item 20: Use None and Docstrings to Specify Dynamic Default Arguments 48
Item 21: Enforce Clarity with Keyword-Only Arguments 51
Chapter 3: Classes and Inheritance 55
Item 22: Prefer Helper Classes Over Bookkeeping with Dictionaries and Tuples 55
Item 23: Accept Functions for Simple Interfaces Instead of Classes 61
Item 24: Use @classmethod Polymorphism to Construct Objects Generically 64
Item 25: Initialize Parent Classes with super 69
Item 26: Use Multiple Inheritance Only for Mix-in Utility Classes 73
Item 27: Prefer Public Attributes Over Private Ones 78
Item 28: Inherit from collections.abc for Custom Container Types 83
Chapter 4: Metaclasses and Attributes 87
Item 29: Use Plain Attributes Instead of Get and Set Methods 87
Item 30: Consider @property Instead of Refactoring Attributes 91
Item 31: Use Descriptors for Reusable @property Methods 95
Item 32: Use __getattr__, __getattribute__, and __setattr__ for Lazy Attributes 100
Item 33: Validate Subclasses with Metaclasses 105
Item 34: Register Class Existence with Metaclasses 108
Item 35: Annotate Class Attributes with Metaclasses 112
Chapter 5: Concurrency and Parallelism 117
Item 36: Use subprocess to Manage Child Processes 118
Item 37: Use Threads for Blocking I/O, Avoid for Parallelism 122
Item 38: Use Lock to Prevent Data Races in Threads 126
Item 39: Use Queue to Coordinate Work Between Threads 129
Item 40: Consider Coroutines to Run Many Functions Concurrently 136
Item 41: Consider concurrent.futures for True Parallelism 145
Chapter 6: Built-in Modules 151
Item 42: Define Function Decorators with functools.wraps 151
Item 43: Consider contextlib and with Statements for Reusable try/finally Behavior 153
Item 44: Make pickle Reliable with copyreg 157
Item 45: Use datetime Instead of time for Local Clocks 162
Item 46: Use Built-in Algorithms and Data Structures 166
Item 47: Use decimal When Precision Is Paramount 171
Item 48: Know Where to Find Community-Built Modules 173
Chapter 7: Collaboration 175
Item 49: Write Docstrings for Every Function, Class, and Module 175
Item 50: Use Packages to Organize Modules and Provide Stable APIs 179
Item 51: Define a Root Exception to Insulate Callers from APIs 184
Item 52: Know How to Break Circular Dependencies 187
Item 53: Use Virtual Environments for Isolated and
Reproducible Dependencies 192
Chapter 8: Production 199
Item 54: Consider Module-Scoped Code to Configure Deployment Environments 199
Item 55: Use repr Strings for Debugging Output 202
Item 56: Test Everything with unittest 204
Item 57: Consider Interactive Debugging with pdb 208
Item 58: Profile Before Optimizing 209
Item 59: Use tracemalloc to Understand Memory Usage and Leaks 214
Index 217
