Effective Python: 59 Specific Ways to Write Better Python

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