Hjem

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